@multiagency/sdk 0.3.1

package/dist/contract/run-log-schema.js

@@ -0,0 +1,150 @@
+import { EventSchemas } from "@ag-ui/core/schemas";
+import { PROTOCOL_VERSION } from "@ag-ui/core";
+import { z } from "zod";
+import { StepNameSchema, SubmissionSchema } from "./run-progress-schema.js";
+/** Private, observational format. No field in this module may authorize an operation. */
+export const AGUI_VERSION = "1.0.3";
+/** Earlier package versions whose recordings stay readable: their events still parse with the current schemas. */
+const READABLE_AGUI_VERSIONS = ["1.0.2", AGUI_VERSION];
+export const AGUI_PROTOCOL_VERSION = PROTOCOL_VERSION;
+export const MAX_RECORDING_BYTES = 2_000_000;
+export const text = z.string().max(4096);
+export const id = z.string().min(1).max(200);
+export const iso = z.iso.datetime({ offset: true });
+const units = z.string().regex(/^\d+$/).max(200);
+const number = z.number().finite();
+export const GapSchema = z.strictObject({ code: id, line: z.number().int().positive().optional(), ref: text.optional() });
+/** A safe projection of one physical journal line, not the folded operation or its raw request. */
+export const JournalRecordSchema = z.strictObject({
+    line: z.number().int().positive(), recordedAt: iso.nullable(), idempotencyKey: id,
+    type: z.enum(["request", "submission-claim", "status", "refusal"]),
+    method: z.enum(["swap", "transfer", "shield", "unshield"]).optional(),
+    planId: id.optional(), correlationId: id.optional(), status: id.optional(), refusal: id.optional(),
+});
+export const JournalHistorySchema = z.strictObject({ agentId: id, records: z.array(JournalRecordSchema).max(20_000), gaps: z.array(GapSchema).max(20_001) });
+export const StartSchema = z.object({
+    progressVersion: z.literal(1).optional(),
+    id, agentId: id, at: iso, trigger: z.enum(["schedule", "operator"]),
+    schedule: z.object({ on: z.boolean(), everyMin: number, maxUsd: number, lastRun: iso.nullable() }),
+    build: z.object({ deployment: text.nullable(), source: text, lockfile: text.nullable(), packageJson: text.nullable() }),
+    policy: z.object({ revision: number.nullable(), digest: text.nullable(), status: text }), strategy: text,
+    grant: z.object({ id, label: text, expiresAt: iso }).nullable(),
+});
+const window = z.object({ limit_usd: z.string().max(200).nullable(), remaining_usd: z.string().max(200).nullable() });
+export const BudgetSchema = z.object({ daily: window, weekly: window, monthly: window });
+export const SeenSchema = z.union([
+    z.object({ error: text }),
+    z.object({ at: iso, book: z.array(z.object({ asset: id, public: units, confidential: units, usd: number })).max(500),
+        weightsBps: z.record(id, number), targetBps: z.record(id, number), driftBps: number, budget: BudgetSchema.nullable(), unresolved: z.number().int().nonnegative() }),
+]);
+export const PlanSchema = z.object({ id, usd: number, legs: z.array(z.object({
+        from: id, to: id, amount: units, amountOut: units, minAmountOut: units, costBps: number,
+    })).max(500) });
+export const DisplaySchema = z.object({ asOf: iso, assets: z.array(z.object({ asset: id, symbol: z.string().min(1).max(80), decimals: z.number().int().min(0).max(255) })).max(500) });
+const result = z.strictObject({ outcome: text, refusal: text.nullable(), rejected: z.array(text).max(500) });
+/** The current tick recorder's explicit failure marker; provider operation statuses are independent. */
+export const recordedTickFailed = (value) => value.refusal === null && value.outcome.startsWith("Failed: ");
+const provenance = z.strictObject({
+    eventId: text, source: z.literal("tick"), recordRef: text, recordedAt: iso.nullable(),
+    observedAt: iso.nullable(), timing: z.enum(["recorded", "observed", "unknown"]),
+});
+const operation = {
+    index: z.number().int().nonnegative(), correlationId: z.string().max(200), status: id, failureCode: text.nullable(),
+    historySource: z.literal("journal"),
+    history: z.array(JournalRecordSchema).max(20_000), untimedHistory: z.array(JournalRecordSchema).max(20_000),
+};
+const payload = z.discriminatedUnion("stage", [
+    SubmissionSchema,
+    z.strictObject({ stage: z.literal("before"), observation: SeenSchema }),
+    z.strictObject({ stage: z.literal("shield"), asset: id, ...operation }),
+    z.strictObject({ stage: z.literal("plan"), plan: PlanSchema.nullable(), summary: text, rejected: z.array(text).max(500) }),
+    z.strictObject({ stage: z.literal("send"), ...operation }),
+    z.strictObject({ stage: z.literal("after"), observation: SeenSchema }),
+]);
+const base = { timestamp: z.number().finite().optional(), metadata: provenance };
+const EventSchema = z.discriminatedUnion("type", [
+    z.strictObject({ type: z.literal("STEP_STARTED"), stepName: StepNameSchema, ...base }),
+    z.strictObject({ type: z.literal("STEP_FINISHED"), stepName: StepNameSchema, ...base }),
+    z.strictObject({ type: z.literal("RUN_STARTED"), threadId: text, runId: id, protocolVersion: z.literal(AGUI_PROTOCOL_VERSION).optional(), ...base }),
+    z.strictObject({ type: z.literal("CUSTOM"), name: z.literal("treasury.observation"), value: payload, ...base }),
+    z.strictObject({ type: z.literal("RUN_FINISHED"), threadId: text, runId: id, result, ...base }),
+    z.strictObject({ type: z.literal("RUN_ERROR"), message: text, code: z.enum(["tick_failed", "progress_incomplete"]),
+        timestamp: base.timestamp, metadata: provenance.extend({ tickResult: result }) }),
+]).superRefine((event, ctx) => {
+    if (!EventSchemas.safeParse(event).success)
+        ctx.addIssue({ code: "custom", message: `Invalid AG-UI ${AGUI_VERSION} event` });
+});
+export const RecordingSchema = z.strictObject({
+    schemaVersion: z.union([z.literal(1), z.literal(2), z.literal(3)]), aguiVersion: z.enum(READABLE_AGUI_VERSIONS), agentId: id, tickId: id, exportedAt: iso,
+    completion: z.enum(["recorded-end", "no-recorded-end"]), context: StartSchema, display: DisplaySchema,
+    gaps: z.array(GapSchema).max(25_000), events: z.array(EventSchema).min(1).max(2000),
+    laterObservations: z.array(z.strictObject({ correlationId: id, source: z.literal("journal"), record: JournalRecordSchema })).max(20_000),
+}).superRefine((recording, ctx) => {
+    const fail = (message) => ctx.addIssue({ code: "custom", message });
+    if (recording.agentId !== recording.context.agentId || recording.tickId !== recording.context.id)
+        fail("Recording identity mismatch");
+    const events = recording.events;
+    if (events[0]?.type !== "RUN_STARTED")
+        fail("Missing run start");
+    const current = recording.schemaVersion === 3;
+    // v1/v2 are retained archives, not retroactively certified protocol streams.
+    if (current && events[0]?.type === "RUN_STARTED" && events[0].protocolVersion !== AGUI_PROTOCOL_VERSION)
+        fail("Missing protocol version");
+    if (!current && events.some(event => event.type === "RUN_ERROR" || (event.type === "RUN_STARTED" && event.protocolVersion !== undefined)))
+        fail("Lifecycle fields require recording version 3");
+    const isProgress = (event) => event.type === "STEP_STARTED" || event.type === "STEP_FINISHED" || (event.type === "CUSTOM" && event.value.stage === "submission");
+    if (recording.schemaVersion === 1 && events.some(isProgress))
+        fail("Progress requires recording version 2");
+    if (recording.completion === "no-recorded-end" && (events.slice(1).some(e => !isProgress(e)) || recording.laterObservations.length))
+        fail("Incomplete tick has inferred events");
+    const active = new Set(), finished = new Set();
+    let progressAt = Date.parse(recording.context.at);
+    for (const event of events.filter(isProgress)) {
+        if (event.metadata.timing !== "recorded" || event.timestamp === undefined || event.timestamp < progressAt || event.timestamp > Date.parse(recording.exportedAt))
+            fail("Invalid progress timing");
+        progressAt = event.timestamp ?? progressAt;
+        if (event.type === "STEP_STARTED") {
+            if (active.has(event.stepName) || finished.has(event.stepName))
+                fail("Repeated stage");
+            active.add(event.stepName);
+        }
+        else if (event.type === "STEP_FINISHED") {
+            if (!active.delete(event.stepName))
+                fail("Stage never started");
+            finished.add(event.stepName);
+        }
+    }
+    const end = events.at(-1);
+    const terminal = end?.type === "RUN_FINISHED" || end?.type === "RUN_ERROR";
+    if (recording.completion === "recorded-end" && !terminal)
+        fail("Missing recorded end");
+    if (terminal && events.filter(isProgress).some(event => event.timestamp > end.timestamp))
+        fail("Progress recorded after run end");
+    if (current && end?.type === "RUN_FINISHED") {
+        if (active.size)
+            fail("Run finished with open stages");
+        if (recordedTickFailed(end.result))
+            fail("Recorded failure requires run error");
+    }
+    if (end?.type === "RUN_ERROR") {
+        if (end.code === "tick_failed" && !recordedTickFailed(end.metadata.tickResult))
+            fail("Run error lacks recorded failure");
+        if (end.code === "progress_incomplete" && !active.size)
+            fail("Progress error has no open stage");
+    }
+    const ids = new Set();
+    for (const [i, event] of events.entries()) {
+        if (ids.has(event.metadata.eventId))
+            fail("Duplicate event identity");
+        ids.add(event.metadata.eventId);
+        if (event.type === "RUN_STARTED" && i !== 0)
+            fail("Unexpected run start");
+        if ((event.type === "RUN_FINISHED" || event.type === "RUN_ERROR") && i !== events.length - 1)
+            fail("Unexpected run end");
+        if ((event.type === "RUN_STARTED" || event.type === "RUN_FINISHED") && (event.runId !== recording.tickId || event.threadId !== `tick:${recording.agentId}:${recording.tickId}`))
+            fail("Event identity mismatch");
+        const time = event.metadata.timing === "recorded" ? event.metadata.recordedAt : event.metadata.observedAt;
+        if (event.metadata.timing === "unknown" ? event.timestamp !== undefined : !time || event.timestamp !== Date.parse(time))
+            fail("Event timing mismatch");
+    }
+});

package/dist/contract/run-progress-schema.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+export declare const STAGE_LABEL: {
+    readonly "balances-before": "Checking balances";
+    readonly recovery: "Checking unresolved operations";
+    readonly sweep: "Checking and shielding public balances";
+    readonly planning: "Planning and quoting swaps";
+    readonly execution: "Checking and executing the plan";
+    readonly "balances-after": "Checking balances after the run";
+};
+export declare const StepNameSchema: z.ZodEnum<{
+    "balances-after": "balances-after";
+    "balances-before": "balances-before";
+    execution: "execution";
+    planning: "planning";
+    recovery: "recovery";
+    sweep: "sweep";
+}>;
+export declare const SubmissionSchema: z.ZodObject<{
+    stage: z.ZodLiteral<"submission">;
+    method: z.ZodEnum<{
+        shield: "shield";
+        swap: "swap";
+        transfer: "transfer";
+        unshield: "unshield";
+    }>;
+    correlationId: z.ZodString;
+}, z.core.$strict>;
+export declare const ProgressEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"STEP_STARTED">;
+    stepName: z.ZodEnum<{
+        "balances-after": "balances-after";
+        "balances-before": "balances-before";
+        execution: "execution";
+        planning: "planning";
+        recovery: "recovery";
+        sweep: "sweep";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"STEP_FINISHED">;
+    stepName: z.ZodEnum<{
+        "balances-after": "balances-after";
+        "balances-before": "balances-before";
+        execution: "execution";
+        planning: "planning";
+        recovery: "recovery";
+        sweep: "sweep";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"CUSTOM">;
+    name: z.ZodLiteral<"treasury.observation">;
+    value: z.ZodObject<{
+        stage: z.ZodLiteral<"submission">;
+        method: z.ZodEnum<{
+            shield: "shield";
+            swap: "swap";
+            transfer: "transfer";
+            unshield: "unshield";
+        }>;
+        correlationId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+export declare const ProgressRecordSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    agentId: z.ZodString;
+    tickId: z.ZodString;
+    sequence: z.ZodNumber;
+    at: z.ZodISODateTime;
+    event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"STEP_STARTED">;
+        stepName: z.ZodEnum<{
+            "balances-after": "balances-after";
+            "balances-before": "balances-before";
+            execution: "execution";
+            planning: "planning";
+            recovery: "recovery";
+            sweep: "sweep";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"STEP_FINISHED">;
+        stepName: z.ZodEnum<{
+            "balances-after": "balances-after";
+            "balances-before": "balances-before";
+            execution: "execution";
+            planning: "planning";
+            recovery: "recovery";
+            sweep: "sweep";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"CUSTOM">;
+        name: z.ZodLiteral<"treasury.observation">;
+        value: z.ZodObject<{
+            stage: z.ZodLiteral<"submission">;
+            method: z.ZodEnum<{
+                shield: "shield";
+                swap: "swap";
+                transfer: "transfer";
+                unshield: "unshield";
+            }>;
+            correlationId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>;
+export type ProgressEvent = z.infer<typeof ProgressEventSchema>;
+export type ProgressRecord = z.infer<typeof ProgressRecordSchema>;

package/dist/contract/run-progress-schema.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export const STAGE_LABEL = {
+    "balances-before": "Checking balances",
+    recovery: "Checking unresolved operations",
+    sweep: "Checking and shielding public balances",
+    planning: "Planning and quoting swaps",
+    execution: "Checking and executing the plan",
+    "balances-after": "Checking balances after the run",
+};
+export const StepNameSchema = z.enum(Object.keys(STAGE_LABEL));
+export const SubmissionSchema = z.strictObject({ stage: z.literal("submission"), method: z.enum(["swap", "shield", "transfer", "unshield"]), correlationId: z.string().min(1).max(200) });
+export const ProgressEventSchema = z.discriminatedUnion("type", [
+    z.strictObject({ type: z.literal("STEP_STARTED"), stepName: StepNameSchema }),
+    z.strictObject({ type: z.literal("STEP_FINISHED"), stepName: StepNameSchema }),
+    z.strictObject({ type: z.literal("CUSTOM"), name: z.literal("treasury.observation"), value: SubmissionSchema }),
+]);
+export const ProgressRecordSchema = z.strictObject({
+    version: z.literal(1), agentId: z.string().regex(/^[a-zA-Z0-9_-]{1,200}$/), tickId: z.string().regex(/^[a-zA-Z0-9_-]{1,200}$/),
+    sequence: z.number().int().positive().max(2000), at: z.iso.datetime({ offset: true }), event: ProgressEventSchema,
+});

package/dist/payee-contract.d.ts

@@ -0,0 +1,9 @@
+/** Additive payee HTTP capabilities; no capability grants authority. */
+export declare const payeeContract: {
+    readonly version: 1;
+    readonly product: "invoices";
+    readonly capabilities: readonly ["supplier-session-v1", "supplier-invoices-v1", "supplier-work-orders-v1", "supplier-work-order-requests-v1", "supplier-compensation-v2", "supplier-agent-connections-v1"];
+};
+/** A release manifest is compatible when its version and product match and every required capability is provided. */
+export declare function compatibleRelease(value: unknown, product: string, provided: readonly string[]): boolean;
+export declare const compatiblePayeeFrontend: (value: unknown) => boolean;

package/dist/payee-contract.js

@@ -0,0 +1,15 @@
+/** Additive payee HTTP capabilities; no capability grants authority. */
+export const payeeContract = {
+    version: 1,
+    product: "invoices",
+    capabilities: ["supplier-session-v1", "supplier-invoices-v1", "supplier-work-orders-v1", "supplier-work-order-requests-v1", "supplier-compensation-v2", "supplier-agent-connections-v1"],
+};
+/** A release manifest is compatible when its version and product match and every required capability is provided. */
+export function compatibleRelease(value, product, provided) {
+    if (!value || typeof value !== "object")
+        return false;
+    const release = value;
+    return release.version === 1 && release.product === product && Array.isArray(release.required) &&
+        release.required.length > 0 && release.required.every(capability => typeof capability === "string" && provided.includes(capability));
+}
+export const compatiblePayeeFrontend = (value) => compatibleRelease(value, payeeContract.product, payeeContract.capabilities);

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@multiagency/sdk",
+  "version": "0.3.1",
+  "type": "module",
+  "license": "MIT",
+  "description": "MultiAgency SDK: payee, compensation and owner-app schemas, typed payee and owner clients, and the shared release asset server.",
+  "keywords": [
+    "tanstack-intent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MultiAgency/platform.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/contract/index.d.ts",
+      "default": "./dist/contract/index.js"
+    },
+    "./payee": {
+      "types": "./dist/contract/payee-entry.d.ts",
+      "default": "./dist/contract/payee-entry.js"
+    },
+    "./contract": {
+      "types": "./dist/contract/owner-contract.d.ts",
+      "default": "./dist/contract/owner-contract.js"
+    },
+    "./schemas/*": "./schemas/*",
+    "./release-server": {
+      "types": "./bin/release-server.d.mts",
+      "default": "./bin/release-server.mjs"
+    }
+  },
+  "bin": {
+    "multiagency-release-server": "bin/release-server.mjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "schemas",
+    "skills",
+    "!skills/_artifacts",
+    "CHANGES.md",
+    "README.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES",
+    "provenance.json"
+  ],
+  "dependencies": {
+    "@orpc/contract": "2.0.0-beta.47",
+    "@ag-ui/core": "1.0.3"
+  },
+  "peerDependencies": {
+    "zod": "^4.6.5"
+  }
+}

package/provenance.json

@@ -0,0 +1,61 @@
+{
+  "name": "@multiagency/sdk",
+  "version": "0.3.1",
+  "wire": {
+    "payeeManifestVersion": 1,
+    "capabilities": [
+      "supplier-session-v1",
+      "supplier-invoices-v1",
+      "supplier-work-orders-v1",
+      "supplier-work-order-requests-v1",
+      "supplier-compensation-v2",
+      "supplier-agent-connections-v1"
+    ]
+  },
+  "sourceHead": "766b3f3a25b6ae90ac4d4f1d8bb65ef5597f6f66",
+  "dirtyPaths": [],
+  "snapshot": {
+    "runDigest": "106ed6be37bc8f6b133006b49b74264cb9519807f20c3b70ad17cb2cbbf12136",
+    "overlayDiffSha256": null
+  },
+  "sources": {
+    "src/compensation-contract.ts": "3443b0690db7921d6dec04375d9281a2e1df3f4ffbe48c2b821e89af177f14c1",
+    "src/contract/agent-connection.ts": "cfe3ec3b3cdc4da2773b20de008e1a004f2862499d0df5831923637f8b39a746",
+    "src/contract/app-access.ts": "f5c792723dcaf870bf000265de9816b819035883cf79227e7de0cccc25681363",
+    "src/contract/app-client.ts": "d1ae48532320e8bfa5337f68b915f699566eea77d59d836ccd55e00676ea82b3",
+    "src/contract/app-consent.ts": "671d5904b448af50bc06aee19bdefa84359494b6cfe38cc0725042703ca6418a",
+    "src/contract/assets.ts": "b6cc3a160e488bfecf273b50e747e4640c8f4ba4d000bd6898db4f805ae9f310",
+    "src/contract/client.ts": "1eabd53e3119078d3c01a18850c180fab45385eec6ad210b92aa7fa158a03996",
+    "src/contract/gateway.ts": "e66bb199ab504b007e5a04617e0cf53b5b3d9641328a799c7df33f8901fa473b",
+    "src/contract/index.ts": "7c2daca088c9841b4e5e986825cd0501ef9f271fb4b9bc2804e83c93b5f938c5",
+    "src/contract/inputs.ts": "a7b16ff1ff05a65bc2bd6b8bdaa978296d912e45098d105e0a578a8174a029d3",
+    "src/contract/intents-account.ts": "8e88f6f41de28fdb48fa49243ccb4e0035dc7823586931658922927cf92f8fea",
+    "src/contract/orpc-client.ts": "94cbd34bc64bd06152f2dbf17d2ff6b270d1d3b703e3bb7019483bcce93eeb04",
+    "src/contract/owner-capabilities.ts": "1cee82270d4c9bf2984e71297515da0763b2e6b3c2d8052c96efed89813fb326",
+    "src/contract/owner-client.ts": "468a2e06784e95242087ecf45af805092de28af4e59ad0d445b29999b145b9f6",
+    "src/contract/owner-contract.ts": "339f63d7b585d652f1fd2175ebc94a5d8ef5e31a1f4730e554c2b0b89b24ab11",
+    "src/contract/owner-inputs.ts": "4328b6734a955fe524cf04852a0e4d9c20cf3c618416c5e91d857c98ffa1b837",
+    "src/contract/owner-outputs.ts": "59e9d8a712c4e6dc60075edaef86fee3f50a6b6c99273cd992431efbdefee75a",
+    "src/contract/package-version.ts": "a1495bd2343727a79d50e56af598990d3efce9e3253538b0d8b09feddc9e0736",
+    "src/contract/payee-entry.ts": "9557ec0f53dd4ab3411d3a81ccd82667f83766386332fb84e93a50caa8287bef",
+    "src/contract/payee.ts": "ec6e0c628be8592b997a5ceccfcd1ca18f891bb969731214fd4205b7e3f07a66",
+    "src/contract/permissions.ts": "fd0280c696cc070390360f20ff941f4ef2cf8143d81d55856103de43a935c93d",
+    "src/contract/proposals.ts": "8a9abb34f1ee09fcfb1de2cc2ced2773d3fa189f20faa0bc1a31ed9fae82beef",
+    "src/contract/run-log-schema.ts": "2ef522a589f6a70cff58e4ded63ddf41a6d3998b2fde96a1bf9176b363da3847",
+    "src/contract/run-progress-schema.ts": "5eead5bde373e8f058f7f42cf588c4a71e1960d5d7097e0381384c03f6a4bbfb",
+    "src/payee-contract.ts": "800260c35c1edbc6e8361f9213fe5f4ccdc22d8d7b1510db08a590f83a152351",
+    "src/contract/release-server.mjs": "a2177a0fc28bc19edefae2e5d5e8e11dffa3c4f099f604cee82457cb8eca51c7",
+    "src/contract/release-server.d.mts": "05fb535f8d1f3ff4aac62395b717144aecf1f4b0c5b388ca83d8b4cb677d2764",
+    "docs/sdk-changes.md": "969bd9a4fcc3774660dea0717798e5e5e300f54d40dc88b104fa75122a0ce567",
+    "src/contract/README.md": "e80e5cbbab40fef5d4a8deadb90b02133b2998df7fc17ff031910e818e6909a9",
+    "LICENSE": "0f90c37abe95e72f99ddb9b9dfc5e54b663d8bfed929d4c261669059443ba822",
+    "src/contract/skills/app-server/SKILL.md": "0bef6c331bc86eeae588c0c54ce2932c25cb5d2d07107912c728213bcf943071",
+    "src/contract/skills/getting-started/SKILL.md": "c8b2bce01aa946c8a6c3540266208e93e3ae08ddb7cf5deff7a6ccae2b92f622",
+    "src/contract/skills/owner-workflows/SKILL.md": "e6b88d764aa8b6cafd1a26ad7a21cbbd842625a9b145c96dd922a6ef6ae080ed",
+    "src/contract/skills/payee-workflows/SKILL.md": "efa1bd5e07d4b06405d54c5fc424d9357ab336883bdd55e66bbd7094bb01441a"
+  },
+  "sourcesDirty": [],
+  "node": "v24.22.1",
+  "typescript": "Version 7.0.2",
+  "builtAt": "2026-10-31T04:39:35.856Z"
+}

package/schemas/agentConnection.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "format": "uuid",
+      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+    },
+    "label": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 80
+    },
+    "role": {
+      "type": "string",
+      "enum": [
+        "payee"
+      ]
+    },
+    "permissions": {
+      "minItems": 1,
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "compensation.read",
+          "compensation.submit"
+        ]
+      }
+    },
+    "host": {
+      "type": "string",
+      "minLength": 1
+    },
+    "instance": {
+      "type": "string",
+      "minLength": 1
+    },
+    "account": {
+      "type": "string",
+      "minLength": 2
+    },
+    "agentId": {
+      "type": "string",
+      "minLength": 1
+    },
+    "createdAt": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$"
+    },
+    "expiresAt": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$"
+    },
+    "revoked": {
+      "type": "boolean"
+    }
+  },
+  "required": [
+    "id",
+    "label",
+    "role",
+    "permissions",
+    "host",
+    "instance",
+    "account",
+    "agentId",
+    "createdAt",
+    "expiresAt",
+    "revoked"
+  ],
+  "additionalProperties": false
+}

package/schemas/agentConnectionIssue.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "label": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 80
+    },
+    "ttlSeconds": {
+      "default": 3600,
+      "type": "integer",
+      "minimum": 60,
+      "maximum": 86400
+    }
+  },
+  "required": [
+    "label",
+    "ttlSeconds"
+  ],
+  "additionalProperties": false
+}

package/schemas/agentConnectionList.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "connections": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "format": "uuid",
+            "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+          },
+          "label": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 80
+          },
+          "role": {
+            "type": "string",
+            "enum": [
+              "payee"
+            ]
+          },
+          "permissions": {
+            "minItems": 1,
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": [
+                "compensation.read",
+                "compensation.submit"
+              ]
+            }
+          },
+          "host": {
+            "type": "string",
+            "minLength": 1
+          },
+          "instance": {
+            "type": "string",
+            "minLength": 1
+          },
+          "account": {
+            "type": "string",
+            "minLength": 2
+          },
+          "agentId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "date-time",
+            "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$"
+          },
+          "expiresAt": {
+            "type": "string",
+            "format": "date-time",
+            "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$"
+          },
+          "revoked": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "id",
+          "label",
+          "role",
+          "permissions",
+          "host",
+          "instance",
+          "account",
+          "agentId",
+          "createdAt",
+          "expiresAt",
+          "revoked"
+        ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": [
+    "connections"
+  ],
+  "additionalProperties": false
+}