@multiagency/sdk 0.3.1

package/dist/contract/package-version.d.ts

@@ -0,0 +1,5 @@
+/** The package name and version, independent of the wire manifest version (`payeeContract.version`). */
+export declare const contractPackage: {
+    readonly name: "@multiagency/sdk";
+    readonly version: "0.3.1";
+};

package/dist/contract/package-version.js

@@ -0,0 +1,2 @@
+/** The package name and version, independent of the wire manifest version (`payeeContract.version`). */
+export const contractPackage = { name: "@multiagency/sdk", version: "0.3.1" };

package/dist/contract/payee-entry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@multiagency/sdk/payee`: the payee side of the contract. It imports zod alone; the owner entry's oRPC and AG-UI
+ * dependencies are installed but never loaded by this entry.
+ */
+export { contractPackage } from "./package-version.js";
+export { payeeContract, compatiblePayeeFrontend, compatibleRelease } from "../payee-contract.js";
+export * from "../compensation-contract.js";
+export * from "./payee.js";
+export * from "./client.js";
+export * from "./agent-connection.js";

package/dist/contract/payee-entry.js

@@ -0,0 +1,10 @@
+/**
+ * `@multiagency/sdk/payee`: the payee side of the contract. It imports zod alone; the owner entry's oRPC and AG-UI
+ * dependencies are installed but never loaded by this entry.
+ */
+export { contractPackage } from "./package-version.js";
+export { payeeContract, compatiblePayeeFrontend, compatibleRelease } from "../payee-contract.js";
+export * from "../compensation-contract.js";
+export * from "./payee.js";
+export * from "./client.js";
+export * from "./agent-connection.js";

package/dist/contract/payee.d.ts

@@ -0,0 +1,326 @@
+import { z } from "zod";
+/** Payee HTTP responses under the instance base. The platform's handlers are tested against these schemas. */
+export declare const invoiceStatus: z.ZodEnum<{
+    busy: "busy";
+    failed: "failed";
+    needs_agreement: "needs_agreement";
+    needs_review: "needs_review";
+    paid: "paid";
+    paying: "paying";
+    prepared: "prepared";
+    refused: "refused";
+    unknown: "unknown";
+    waiting: "waiting";
+}>;
+export declare const agreementStatus: z.ZodEnum<{
+    agreed: "agreed";
+    declined: "declined";
+    filed: "filed";
+    proposed: "proposed";
+    requested: "requested";
+}>;
+export declare const errorBody: z.ZodObject<{
+    error: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const session: z.ZodObject<{
+    account: z.ZodNullable<z.ZodString>;
+    agreed: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const compensationSession: z.ZodObject<{
+    account: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const signInResult: z.ZodObject<{
+    account: z.ZodString;
+    agreed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const signOutResult: z.ZodObject<{
+    account: z.ZodNull;
+}, z.core.$strip>;
+export declare const invoice: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodNullable<z.ZodString>;
+    note: z.ZodString;
+    filedAt: z.ZodString;
+    status: z.ZodEnum<{
+        busy: "busy";
+        failed: "failed";
+        needs_agreement: "needs_agreement";
+        needs_review: "needs_review";
+        paid: "paid";
+        paying: "paying";
+        prepared: "prepared";
+        refused: "refused";
+        unknown: "unknown";
+        waiting: "waiting";
+    }>;
+    revisionConflict: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const agreement: z.ZodObject<{
+    id: z.ZodString;
+    origin: z.ZodEnum<{
+        owner: "owner";
+        payee: "payee";
+    }>;
+    amount: z.ZodString;
+    note: z.ZodString;
+    submission: z.ZodOptional<z.ZodString>;
+    terms: z.ZodOptional<z.ZodObject<{
+        maxAmount: z.ZodString;
+        until: z.ZodString;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        agreed: "agreed";
+        declined: "declined";
+        filed: "filed";
+        proposed: "proposed";
+        requested: "requested";
+    }>;
+    at: z.ZodString;
+}, z.core.$strip>;
+export declare const invoicesView: z.ZodObject<{
+    invoices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNullable<z.ZodString>;
+        note: z.ZodString;
+        filedAt: z.ZodString;
+        status: z.ZodEnum<{
+            busy: "busy";
+            failed: "failed";
+            needs_agreement: "needs_agreement";
+            needs_review: "needs_review";
+            paid: "paid";
+            paying: "paying";
+            prepared: "prepared";
+            refused: "refused";
+            unknown: "unknown";
+            waiting: "waiting";
+        }>;
+        revisionConflict: z.ZodBoolean;
+    }, z.core.$strip>>;
+    agreements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        origin: z.ZodEnum<{
+            owner: "owner";
+            payee: "payee";
+        }>;
+        amount: z.ZodString;
+        note: z.ZodString;
+        submission: z.ZodOptional<z.ZodString>;
+        terms: z.ZodOptional<z.ZodObject<{
+            maxAmount: z.ZodString;
+            until: z.ZodString;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            agreed: "agreed";
+            declined: "declined";
+            filed: "filed";
+            proposed: "proposed";
+            requested: "requested";
+        }>;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    agreed: z.ZodBoolean;
+}, z.core.$strip>;
+/** POST /api/invoices and /api/invoices/:id/continue. An account not yet agreed receives an agreement request instead. */
+export declare const fileResult: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        busy: "busy";
+        failed: "failed";
+        needs_agreement: "needs_agreement";
+        needs_review: "needs_review";
+        paid: "paid";
+        paying: "paying";
+        prepared: "prepared";
+        refused: "refused";
+        unknown: "unknown";
+        waiting: "waiting";
+    }>;
+    revisionConflict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodUnion<readonly [z.ZodEnum<{
+        agreed: "agreed";
+        declined: "declined";
+        filed: "filed";
+        proposed: "proposed";
+        requested: "requested";
+    }>, z.ZodLiteral<"busy">]>;
+}, z.core.$strip>]>;
+export declare const workOrderSummary: z.ZodObject<{
+    id: z.ZodUUID;
+    amount: z.ZodString;
+    note: z.ZodString;
+    until: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const workOrderList: z.ZodObject<{
+    orders: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        amount: z.ZodString;
+        note: z.ZodString;
+        until: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicWorkOrder: z.ZodObject<{
+    id: z.ZodUUID;
+    amount: z.ZodString;
+    note: z.ZodString;
+    until: z.ZodString;
+    createdAt: z.ZodString;
+    invoice: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNullable<z.ZodString>;
+        note: z.ZodString;
+        filedAt: z.ZodString;
+        status: z.ZodEnum<{
+            busy: "busy";
+            failed: "failed";
+            needs_agreement: "needs_agreement";
+            needs_review: "needs_review";
+            paid: "paid";
+            paying: "paying";
+            prepared: "prepared";
+            refused: "refused";
+            unknown: "unknown";
+            waiting: "waiting";
+        }>;
+        revisionConflict: z.ZodBoolean;
+    }, z.core.$strip>>;
+    ready: z.ZodBoolean;
+    unavailable: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const payeeWorkOrderRequest: z.ZodObject<{
+    submission: z.ZodUUID;
+    amount: z.ZodString;
+    note: z.ZodString;
+    until: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const workOrderRequestResult: z.ZodObject<{
+    id: z.ZodUUID;
+    status: z.ZodLiteral<"requested">;
+}, z.core.$strip>;
+/** Member identities are redacted to "owner" before they reach the payee. */
+export declare const payeeCompensationView: z.ZodObject<{
+    account: z.ZodString;
+    agreements: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        version: z.ZodNumber;
+        terms: z.ZodObject<{
+            payee: z.ZodString;
+            title: z.ZodString;
+            document: z.ZodURL;
+            signedOn: z.ZodString;
+            start: z.ZodString;
+            end: z.ZodString;
+            ceiling: z.ZodString;
+            openingApproved: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strict>;
+        recordedBy: z.ZodString;
+        at: z.ZodString;
+        approved: z.ZodString;
+        remaining: z.ZodString;
+    }, z.core.$strip>>;
+    requests: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        version: z.ZodNumber;
+        payee: z.ZodString;
+        agreementVersion: z.ZodNumber;
+        report: z.ZodObject<{
+            agreementId: z.ZodUUID;
+            amount: z.ZodOptional<z.ZodString>;
+            start: z.ZodString;
+            end: z.ZodString;
+            contributions: z.ZodString;
+            assessment: z.ZodString;
+            evidence: z.ZodArray<z.ZodURL>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            declined: "declined";
+            draft: "draft";
+            submitted: "submitted";
+        }>;
+        approvedAmount: z.ZodOptional<z.ZodString>;
+        feedback: z.ZodString;
+        reviewedBy: z.ZodNullable<z.ZodString>;
+        at: z.ZodString;
+        payment: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            mode: z.ZodEnum<{
+                isolated: "isolated";
+                shared: "shared";
+            }>;
+            id: z.ZodUUID;
+            until: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodNumber;
+        actor: z.ZodString;
+        record: z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodUUID;
+            version: z.ZodNumber;
+            payee: z.ZodString;
+            agreementVersion: z.ZodNumber;
+            report: z.ZodObject<{
+                agreementId: z.ZodUUID;
+                amount: z.ZodOptional<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                contributions: z.ZodString;
+                assessment: z.ZodString;
+                evidence: z.ZodArray<z.ZodURL>;
+            }, z.core.$strict>;
+            state: z.ZodEnum<{
+                approved: "approved";
+                changes_requested: "changes_requested";
+                declined: "declined";
+                draft: "draft";
+                submitted: "submitted";
+            }>;
+            approvedAmount: z.ZodOptional<z.ZodString>;
+            feedback: z.ZodString;
+            reviewedBy: z.ZodNullable<z.ZodString>;
+            at: z.ZodString;
+            payment: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                mode: z.ZodEnum<{
+                    isolated: "isolated";
+                    shared: "shared";
+                }>;
+                id: z.ZodUUID;
+                until: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodUUID;
+            version: z.ZodNumber;
+            terms: z.ZodObject<{
+                payee: z.ZodString;
+                title: z.ZodString;
+                document: z.ZodURL;
+                signedOn: z.ZodString;
+                start: z.ZodString;
+                end: z.ZodString;
+                ceiling: z.ZodString;
+                openingApproved: z.ZodString;
+                scope: z.ZodString;
+            }, z.core.$strict>;
+            recordedBy: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+    payments: z.ZodArray<z.ZodObject<{
+        requestId: z.ZodUUID;
+        id: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type InvoiceStatus = z.infer<typeof invoiceStatus>;
+export type Invoice = z.infer<typeof invoice>;
+export type Agreement = z.infer<typeof agreement>;
+export type PublicWorkOrder = z.infer<typeof publicWorkOrder>;
+export type PayeeWorkOrderRequest = z.infer<typeof payeeWorkOrderRequest>;
+export type PayeeCompensationView = z.infer<typeof payeeCompensationView>;

package/dist/contract/payee.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { agreementRecord, compensationView, requestRecord } from "../compensation-contract.js";
+/** Payee HTTP responses under the instance base. The platform's handlers are tested against these schemas. */
+export const invoiceStatus = z.enum(["needs_agreement", "refused", "busy", "prepared", "waiting", "paying", "paid", "failed", "unknown", "needs_review"]);
+export const agreementStatus = z.enum(["requested", "proposed", "agreed", "filed", "declined"]);
+export const errorBody = z.object({ error: z.string(), code: z.string().optional() });
+export const session = z.object({ account: z.string().nullable(), agreed: z.boolean() });
+export const compensationSession = z.object({ account: z.string().nullable() });
+export const signInResult = z.object({ account: z.string(), agreed: z.boolean().optional() });
+export const signOutResult = z.object({ account: z.null() });
+export const invoice = z.object({ id: z.string(), amount: z.string().nullable(), note: z.string(), filedAt: z.string(), status: invoiceStatus, revisionConflict: z.boolean() });
+export const agreement = z.object({ id: z.string(), origin: z.enum(["owner", "payee"]), amount: z.string(), note: z.string(), submission: z.string().optional(),
+    terms: z.object({ maxAmount: z.string(), until: z.string() }).optional(), status: agreementStatus, at: z.string() });
+export const invoicesView = z.object({ invoices: z.array(invoice), agreements: z.array(agreement), agreed: z.boolean() });
+/** POST /api/invoices and /api/invoices/:id/continue. An account not yet agreed receives an agreement request instead. */
+export const fileResult = z.union([
+    z.object({ id: z.string(), status: invoiceStatus, revisionConflict: z.boolean().optional() }),
+    z.object({ id: z.string(), status: z.union([agreementStatus, z.literal("busy")]) }),
+]);
+export const workOrderSummary = z.object({ id: z.uuid(), amount: z.string(), note: z.string(), until: z.string(), createdAt: z.string() });
+export const workOrderList = z.object({ orders: z.array(workOrderSummary) });
+export const publicWorkOrder = workOrderSummary.extend({ invoice: invoice.nullable(), ready: z.boolean(), unavailable: z.boolean() });
+export const payeeWorkOrderRequest = z.object({ submission: z.uuid(), amount: z.string(), note: z.string().trim().min(1).max(200), until: z.iso.datetime() }).strict();
+export const workOrderRequestResult = z.object({ id: z.uuid(), status: z.literal("requested") });
+/** Member identities are redacted to "owner" before they reach the payee. */
+export const payeeCompensationView = z.object({
+    account: z.string(),
+    agreements: compensationView.shape.agreements,
+    requests: z.array(requestRecord),
+    history: z.array(z.object({ sequence: z.number(), actor: z.string(), record: z.union([requestRecord, agreementRecord]) })),
+    payments: z.array(z.object({ requestId: z.uuid(), id: z.string(), status: z.string() })),
+});

package/dist/contract/permissions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The procedure→permission map, as data. Single source: the gateway enforces with this same module
+ * (src/gateway/allowlist.ts); apps may mirror it to present controls, but presenting never authorizes.
+ */
+/** What an admitted account may do with an agent (resolved by the gateway from ownership and DAO roles). */
+export type Access = {
+    canSign: boolean;
+    canPropose: boolean;
+    canVote: boolean;
+    canExecute: boolean;
+    canManage: boolean;
+};
+/**
+ * Agent-server procedures by capability, shared with the dashboard. Unknown paths are denied even
+ * to wallet owners. These controls do not replace the provider's policy, grant or owner signature.
+ */
+export declare const READS: Set<string>;
+export declare const OWNER_PROPOSALS: Set<string>;
+/** Whether this admitted account may call `path` (`owner/prepare`, without the `/rpc/` prefix). */
+export declare function mayCall(access: Access, path: string): boolean;

package/dist/contract/permissions.js

@@ -0,0 +1,64 @@
+/**
+ * Agent-server procedures by capability, shared with the dashboard. Unknown paths are denied even
+ * to wallet owners. These controls do not replace the provider's policy, grant or owner signature.
+ */
+export const READS = new Set([
+    "setup",
+    "instance",
+    "overview",
+    "policyHistory",
+    "treasury/get",
+    "activity",
+    "unresolved",
+    "held",
+    "autopilot/get",
+    "strategy/get",
+    "autopilot/evidence",
+    "autopilot/log",
+    "inbox/list",
+    "ledger",
+    "ledgerCsv",
+    "reconcileBooks",
+    "owner/status",
+    "owner/pending",
+    "owner/actions",
+    "paymentHistory",
+    "paymentStatus",
+    "payouts/status",
+    "agreements/list",
+    "invoices",
+    "compensation/list",
+    "workOrders/list",
+    "workOrders/get",
+    "workOrders/status",
+    "demoGuide/compose",
+]);
+export const OWNER_PROPOSALS = new Set([
+    "owner/prepare",
+    "agreements/propose",
+    "agreements/offer",
+    "workOrders/create",
+    "workOrders/prepare",
+]);
+const PREPARE = new Set([...OWNER_PROPOSALS, "rebalance", "externalPlan", "steward/propose", "deposit", "treasury/fund", "workOrders/deposit"]);
+const EXECUTE = new Set(["workOrders/file", "compensation/prepare", "compensation/send", "compensation/review", "pay", "payouts/request", "sweep", "executePlan", "autopilot/tick", "autopilot/enable"]);
+const MANAGE = new Set(["compensation/agreement", "strategy/save", "treasury/link", "treasury/unlink", "treasury/setConfidential", "agreements/decline"]);
+const MAINTAIN = new Set(["autopilot/stop", "recover", "inbox/dismiss", "cancelPreparedInvoice"]);
+/** Whether this admitted account may call `path` (`owner/prepare`, without the `/rpc/` prefix). */
+export function mayCall(access, path) {
+    if (READS.has(path))
+        return true;
+    if (PREPARE.has(path))
+        return access.canSign || access.canPropose;
+    if (path === "owner/submit" || path === "workOrders/submit")
+        return access.canSign;
+    if (EXECUTE.has(path))
+        return access.canExecute;
+    if (MANAGE.has(path))
+        return access.canManage;
+    if (path === "autopilot/set")
+        return access.canManage && access.canExecute;
+    if (MAINTAIN.has(path))
+        return access.canManage || access.canExecute;
+    return false;
+}

package/dist/contract/proposals.d.ts

@@ -0,0 +1,178 @@
+import { z } from "zod";
+/**
+ * `GET /gw/proposals?dao=<account>`: the DAO's recent agent-owner signing proposals, each matched against what the
+ * agents wait for. Single source: the gateway's `decodeProposals` (src/gateway/proposals.ts) returns these types.
+ */
+export declare const proposalCheck: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"verified">;
+    standard: z.ZodLiteral<"nep413">;
+    message: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"verified">;
+    standard: z.ZodLiteral<"nep366">;
+    receiver: z.ZodString;
+    methods: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"mismatch">;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+export declare const decodedProposal: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"agent">;
+    agent: z.ZodString;
+    type: z.ZodString;
+    correlationId: z.ZodString;
+    expiresAt: z.ZodString;
+    state: z.ZodEnum<{
+        done: "done";
+        expired: "expired";
+        waiting: "waiting";
+    }>;
+    check: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"verified">;
+        standard: z.ZodLiteral<"nep413">;
+        message: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"verified">;
+        standard: z.ZodLiteral<"nep366">;
+        receiver: z.ZodString;
+        methods: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"mismatch">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"unknown">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"unchecked">;
+    unanswered: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"past">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"trezu">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"other">;
+    path: z.ZodString;
+}, z.core.$strip>]>;
+export declare const proposalsResponse: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"agent">;
+    agent: z.ZodString;
+    type: z.ZodString;
+    correlationId: z.ZodString;
+    expiresAt: z.ZodString;
+    state: z.ZodEnum<{
+        done: "done";
+        expired: "expired";
+        waiting: "waiting";
+    }>;
+    check: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"verified">;
+        standard: z.ZodLiteral<"nep413">;
+        message: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"verified">;
+        standard: z.ZodLiteral<"nep366">;
+        receiver: z.ZodString;
+        methods: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"mismatch">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"unknown">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"unchecked">;
+    unanswered: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"past">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"trezu">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    proposer: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodString;
+    submittedAt: z.ZodString;
+    votes: z.ZodRecord<z.ZodString, z.ZodString>;
+    hash: z.ZodString;
+    what: z.ZodLiteral<"other">;
+    path: z.ZodString;
+}, z.core.$strip>]>>;
+export type ProposalCheck = z.infer<typeof proposalCheck>;
+export type Decoded = z.infer<typeof decodedProposal>;

package/dist/contract/proposals.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * `GET /gw/proposals?dao=<account>`: the DAO's recent agent-owner signing proposals, each matched against what the
+ * agents wait for. Single source: the gateway's `decodeProposals` (src/gateway/proposals.ts) returns these types.
+ */
+export const proposalCheck = z.union([
+    /** The hash is recomputed from the readable payload: this is exactly what the vote signs. */
+    z.object({ kind: z.literal("verified"), standard: z.literal("nep413"), message: z.unknown() }),
+    /** The hash is recomputed from the delegate bytes; receiver and methods are read, the policy blob is encrypted. */
+    z.object({ kind: z.literal("verified"), standard: z.literal("nep366"), receiver: z.string(), methods: z.array(z.string()) }),
+    z.object({ kind: z.literal("mismatch"), reason: z.string() }),
+]);
+const base = { id: z.number(), proposer: z.string(), description: z.string(), status: z.string(), submittedAt: z.string(), votes: z.record(z.string(), z.string()), hash: z.string() };
+export const decodedProposal = z.union([
+    z.object({ ...base, what: z.literal("agent"), agent: z.string(), type: z.string(), correlationId: z.string(), expiresAt: z.string(),
+        state: z.enum(["waiting", "done", "expired"]), check: proposalCheck }),
+    /** An agent-owner signature nothing here prepared, every agent having answered: don't approve it without knowing where it's from. */
+    z.object({ ...base, what: z.literal("unknown") }),
+    /** An agent-owner signature no answering agent prepared, while `unanswered` agents couldn't be asked: not yet checkable. */
+    z.object({ ...base, what: z.literal("unchecked"), unanswered: z.array(z.string()) }),
+    /** A finished agent-owner proposal: what it signed was submitted and is no longer waited for. */
+    z.object({ ...base, what: z.literal("past") }),
+    /** Trezu's own confidential payment, signed on the DAO's path rather than the agents'. */
+    z.object({ ...base, what: z.literal("trezu") }),
+    z.object({ ...base, what: z.literal("other"), path: z.string() }),
+]);
+export const proposalsResponse = z.array(decodedProposal);