@openvtc/trust-tasks 0.3.0 → 0.4.1

package/src/audit/verify/0.1/payload.ts

@@ -3,6 +3,11 @@
  * Source: specs/audit/verify/0.1/payload.schema.json
  */
 
+/**
+ * The `entryHash` of the newest envelope reached, in the same multibase-multihash encoding the envelope carries it. Absent when the log is empty.
+ */
+export type DigestMultibase = string;
+
 /**
  * Request to verify the integrity of a maintainer's append-only audit hash chain. The request carries no parameters — verification is store-wide.
  */
@@ -39,10 +44,7 @@ export interface AuditVerifyResponsePayload {
    * Envelopes that could not be deserialized and so could not be checked. Reported at the same prominence as a break, not swallowed.
    */
   unparseableSkipped: number;
-  /**
-   * Hex `entryHash` of the newest envelope reached. Absent when the log is empty.
-   */
-  head?: string;
+  head?: DigestMultibase;
   chainBreak?: ChainBreak;
   ext?: Ext;
 }
@@ -68,7 +70,7 @@ export interface ChainBreak {
 export const TYPE_URI = "https://trusttasks.org/spec/audit/verify/0.1" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = AuditVerifyPayload;
+export type Payload = DigestMultibase;
 
 /** Trust Task response type URI (request type URI + "#response"). */
 export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/audit/verify/0.1#response" as const;

package/src/chat/message/0.1/payload.ts

@@ -3,6 +3,15 @@
  * Source: specs/chat/message/0.1/payload.schema.json
  */
 
+/**
+ * OPTIONAL. Multibase-encoded multihash over the attachment bytes, so the reference is itself verifiable and tamper-evident. Taken over the bytes as transferred, not over any JSON wrapper.
+ */
+export type DigestMultibase = string;
+/**
+ * Multibase-encoded multihash over the RFC 8785 (JCS) canonicalization of the previous document, so a gap, reorder, or removal in the chain is detectable. The algorithm travels in the multihash rather than being fixed here.
+ */
+export type DigestMultibase1 = string;
+
 /**
  * A conversational message exchanged between an AI agent and a messaging-platform bridge. Signed by its author (via the document `proof`) and hash-linked to the previous message in the conversation (`prev`), so a third party can verify each message's author and ordering after the transport has closed — for audit and dispute resolution. Conversations and contacts are referenced by opaque, bridge-issued handles, never raw platform addresses.
  */
@@ -85,10 +94,7 @@ export interface AttachmentRef {
    * OPTIONAL. Size in bytes, if known ahead of fetch.
    */
   sizeBytes?: number;
-  /**
-   * OPTIONAL. Multihash digest of the attachment bytes, so the reference is itself verifiable and tamper-evident.
-   */
-  digest?: string;
+  digest?: DigestMultibase;
 }
 /**
  * OPTIONAL on the first message in a conversation; present on every message thereafter. Links to the previous message so the conversation forms a verifiable, ordered chain.
@@ -98,10 +104,7 @@ export interface ChainLink {
    * The `id` of the previous `chat/message` Trust Task document in this conversation.
    */
   id: string;
-  /**
-   * Multihash digest (e.g. `sha-256`) over the previous document, so a gap, reorder, or removal in the chain is detectable.
-   */
-  digest: string;
+  digest: DigestMultibase1;
 }
 /**
  * Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.
@@ -114,7 +117,7 @@ export interface Ext {
 export const TYPE_URI = "https://trusttasks.org/spec/chat/message/0.1" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = ChatMessagePayload;
+export type Payload = DigestMultibase;
 
 /**
  * SPEC.md §7.2 policy for the request variant, from this specification's

package/src/consent/request/1.0/payload.ts

@@ -3,6 +3,11 @@
  * Source: specs/consent/request/1.0/payload.schema.json
  */
 
+/**
+ * Optional multibase-encoded multihash over the rfc 8785 (jcs) canonicalization of the held first message, binding the request to concrete content.
+ */
+export type DigestMultibase = string;
+
 /**
  * A bridge asks the VTA whether an inbound conversation may reach an AI agent, prompting operator consent on first contact.
  */
@@ -20,10 +25,7 @@ export interface ConsentRequestPayload {
    * Optional operator-facing label (e.g. "Signal group 'Family'"). MUST NOT contain a raw platform address.
    */
   displayHint?: string;
-  /**
-   * Optional multihash digest of the held first message, binding the request to concrete content.
-   */
-  firstMessageDigest?: string;
+  firstMessageDigest?: DigestMultibase;
   /**
    * Optional VTA context path the bridge runs under, to scope approver resolution.
    */
@@ -80,7 +82,7 @@ export interface ConsentRequestResponsePayload {
 export const TYPE_URI = "https://trusttasks.org/spec/consent/request/1.0" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = ConsentRequestPayload;
+export type Payload = DigestMultibase;
 
 /** Trust Task response type URI (request type URI + "#response"). */
 export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/consent/request/1.0#response" as const;

package/src/credentials/_shared/0.2/credentials.ts

@@ -0,0 +1,15 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/credentials/_shared/0.2/credentials.schema.json
+ */
+
+/**
+ * The credential-minting core shared by every family that issues or revokes a Verifiable Credential (vta/credentials/*, vtc/endorsements/*, and future issuers). A family embeds these definitions rather than restating them, so the issuance receipt and the revocation receipt have one canonical shape across the registry. Families remain separate Trust Tasks because their trust semantics differ (approval plane, third-party verifiability, governance gating); only the mechanism is shared.
+ *
+ * Two levels of reuse are offered. A family whose response IS a receipt embeds `IssuedCredential` / `RevocationReceipt` whole, as vtc/endorsements does. A family whose response carries additional members alongside the receipt fields cannot do that — these definitions are `additionalProperties: false`, so composing one via `allOf` would reject the extra members — and instead references `CredentialId`, the identifier both receipts are keyed by, as vta/credentials does.
+ *
+ * `CredentialId` is hoisted and the other members are not, deliberately: it is the one field carrying a constraint worth stating once (non-empty), and the code generators mint a named type per `$def`, so hoisting a plain timestamp or the opaque credential object would wrap `expiresAt` and `credential` in newtypes for every consumer while deduplicating nothing but a description.
+ */
+export interface CredentialsSharedIssuanceAndRevocationDefinitions {
+  [k: string]: unknown | undefined;
+}

package/src/index.ts

@@ -7,6 +7,7 @@ export * from "./_runtime/index.js";
 
 export * as FrameworkShared_v0_1 from "./_framework/0.1/framework.js";
 export * as FrameworkShared_v0_2 from "./_framework/0.2/framework.js";
+export * as FrameworkShared_v0_3 from "./_framework/0.3/framework.js";
 export * as AclEntryShared_v0_1 from "./acl/_shared/0.1/acl-entry.js";
 export * as AclChangeRole_v0_1 from "./acl/change-role/0.1/payload.js";
 export * as AclGrant_v0_1 from "./acl/grant/0.1/payload.js";
@@ -70,6 +71,7 @@ export * as CredentialExchangePresent_v0_1 from "./credential-exchange/present/0
 export * as CredentialExchangeQuery_v0_1 from "./credential-exchange/query/0.1/payload.js";
 export * as CredentialExchangeRequest_v0_1 from "./credential-exchange/request/0.1/payload.js";
 export * as CredentialsShared_v0_1 from "./credentials/_shared/0.1/credentials.js";
+export * as CredentialsShared_v0_2 from "./credentials/_shared/0.2/credentials.js";
 export * as DeviceBindingShared_v0_1 from "./device/_shared/0.1/device-binding.js";
 export * as DeviceBindingShared_v0_2 from "./device/_shared/0.2/device-binding.js";
 export * as DeviceDisable_v0_1 from "./device/disable/0.1/payload.js";
@@ -205,6 +207,7 @@ export * as TrustTaskDiscovery_v0_1 from "./trust-task-discovery/0.1/payload.js"
 export * as TrustTaskError_v0_1 from "./trust-task-error/0.1/payload.js";
 export * as TrustTaskError_v0_2 from "./trust-task-error/0.2/payload.js";
 export * as TrustTaskError_v0_3 from "./trust-task-error/0.3/payload.js";
+export * as TrustTaskNextStep_v0_1 from "./trust-task-next-step/0.1/payload.js";
 export * as ConsumerContextShared_v0_1 from "./vault/_shared/0.1/consumer-context.js";
 export * as SealedEnvelopeShared_v0_1 from "./vault/_shared/0.1/sealed-envelope.js";
 export * as SessionBlobShared_v0_1 from "./vault/_shared/0.1/session-blob.js";
@@ -241,6 +244,7 @@ export * as VtaContextsDidTemplatesList_v1_0 from "./vta/contexts/did-templates/
 export * as VtaContextsDidTemplatesRender_v1_0 from "./vta/contexts/did-templates/render/1.0/payload.js";
 export * as VtaContextsDidTemplatesUpdate_v1_0 from "./vta/contexts/did-templates/update/1.0/payload.js";
 export * as VtaCredentialsIssue_v0_1 from "./vta/credentials/issue/0.1/payload.js";
+export * as VtaCredentialsIssue_v0_2 from "./vta/credentials/issue/0.2/payload.js";
 export * as VtaCredentialsRevoke_v0_1 from "./vta/credentials/revoke/0.1/payload.js";
 export * as VtaDidTemplatesCreate_v1_0 from "./vta/did-templates/create/1.0/payload.js";
 export * as VtaDidTemplatesCreate_v2_0 from "./vta/did-templates/create/2.0/payload.js";
@@ -332,6 +336,7 @@ export * as VtcRegistryDiagnostics_v0_1 from "./vtc/registry/diagnostics/0.1/pay
 export * as VtcRelationshipsGraph_v0_1 from "./vtc/relationships/graph/0.1/payload.js";
 export * as VtcRelationshipsList_v0_1 from "./vtc/relationships/list/0.1/payload.js";
 export * as VtcRelationshipsPublish_v0_1 from "./vtc/relationships/publish/0.1/payload.js";
+export * as VtcRelationshipsRequest_v0_1 from "./vtc/relationships/request/0.1/payload.js";
 export * as VtcRelationshipsRevoke_v0_1 from "./vtc/relationships/revoke/0.1/payload.js";
 export * as VtcWebsiteFilesDelete_v0_1 from "./vtc/website/files/delete/0.1/payload.js";
 export * as VtcWebsiteFilesList_v0_1 from "./vtc/website/files/list/0.1/payload.js";

package/src/policy/evaluate/0.3/payload.ts

@@ -3,6 +3,10 @@
  * Source: specs/policy/evaluate/0.3/payload.schema.json
  */
 
+/**
+ * Multibase-encoded multihash over the RFC 8785 (JCS) canonicalization of the payload, salted with the request challenge, present when a delegated-execution consent flow must bind approval to this exact payload. Absent when no consent binding is in play.
+ */
+export type DigestMultibase = string;
 /**
  * A single binding target for a vault entry. Tagged union over the discriminator `kind`. A VaultEntry's `targets` array MAY mix any number of these.
  */
@@ -42,10 +46,7 @@ export interface PolicyInput {
      * The identifier the task acts on — the value at the spec's `subjectPath` (usually a DID). The evaluator checks the consumer's authority to act on this subject. Absent for subjectless tasks (discovery, list).
      */
     subject?: string;
-    /**
-     * Multihash of the canonicalized payload, salted with the request challenge, present when a delegated-execution consent flow must bind approval to this exact payload. Absent when no consent binding is in play.
-     */
-    payloadDigest?: string;
+    payloadDigest?: DigestMultibase;
     /**
      * Authoritative integrity class (SPEC §7.3 item 13). The evaluator MUST derive this from the compiled handler it is about to invoke, not from the wire — the registry's declared value is advisory only.
      */
@@ -176,7 +177,7 @@ export interface PolicyDecision {
 export const TYPE_URI = "https://trusttasks.org/spec/policy/evaluate/0.3" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = SiteTarget;
+export type Payload = DigestMultibase;
 
 /** Trust Task response type URI (request type URI + "#response"). */
 export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/policy/evaluate/0.3#response" as const;

package/src/task-consent/decision/0.1/payload.ts

@@ -3,10 +3,18 @@
  * Source: specs/task-consent/decision/0.1/payload.schema.json
  */
 
+/**
+ * Echoes the digest of the task being authorized, in the encoding `task-consent/request` carried it. The executor re-derives it from the payload it is about to execute and refuses on mismatch — this is what makes the approved payload the executed payload, cryptographically rather than by convention.
+ */
+export type DigestMultibase = string;
 /**
  * The approver's answer. `deny` aborts the pending request; a subsequent submit of the same task starts a fresh one.
  */
 export type Decision = "approve" | "deny";
+/**
+ * The digest this decision concerned, in the encoding `task-consent/request` carried it.
+ */
+export type DigestMultibase1 = string;
 
 /**
  * An enrolled approver authorizes (or refuses) one pending privileged task, bound to the exact payload it was shown. The proof on this document — not the transport session that carried it — is the authorization.
@@ -16,10 +24,7 @@ export interface TaskConsentDecisionPayload {
    * Echoes the task-consent/request this decision answers, binding it to that one pending request. An executor MUST consume the challenge at execution rather than on receipt of this decision: a decision authorizes exactly one execution, and consuming it earlier lets an executor's own retry legitimately replay it.
    */
   challenge: string;
-  /**
-   * Echoes the digest of the task being authorized. The executor re-derives it from the payload it is about to execute and refuses on mismatch — this is what makes the approved payload the executed payload, cryptographically rather than by convention.
-   */
-  payloadDigest: string;
+  payloadDigest: DigestMultibase;
   decision: Decision;
   /**
    * OPTIONAL human-facing note, most useful on a `deny`.
@@ -41,10 +46,7 @@ export interface TaskConsentDecisionResponsePayload {
    * `granted` = the threshold is met and the requester's re-submit will now execute. `pending` = the approval was recorded but more are needed. `denied` = the request was aborted.
    */
   status: "granted" | "pending" | "denied";
-  /**
-   * The digest this decision concerned.
-   */
-  payloadDigest: string;
+  payloadDigest: DigestMultibase1;
   /**
    * Distinct approvals recorded so far.
    */
@@ -60,7 +62,7 @@ export interface TaskConsentDecisionResponsePayload {
 export const TYPE_URI = "https://trusttasks.org/spec/task-consent/decision/0.1" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = Decision;
+export type Payload = DigestMultibase;
 
 /** Trust Task response type URI (request type URI + "#response"). */
 export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/task-consent/decision/0.1#response" as const;

package/src/task-consent/granted/0.1/payload.ts

@@ -3,6 +3,11 @@
  * Source: specs/task-consent/granted/0.1/payload.schema.json
  */
 
+/**
+ * The salted wire digest of the approved task — the same value the matching task-consent/request carried and the decision echoed. The requester already holds it; it is repeated here only so the requester can correlate the notice to the pending task it should now re-submit. It confers nothing: the executor's single-use grant lookup at re-submit is the authorization.
+ */
+export type DigestMultibase = string;
+
 /**
  * Fire-and-forget notice from the executor to the requester that its pending task has reached the approval threshold and a single-use grant is waiting, so the requester re-submits at once instead of polling. Non-load-bearing by design: the grant check at re-submit is the real gate, so a lost or spurious notice costs at most one poll cycle.
  */
@@ -11,10 +16,7 @@ export interface TaskConsentGrantedPayload {
    * Always `granted`. A denial sends no notice — the requester's re-submit discovers it, and a notice that could carry a denial would tempt a consumer into treating this advisory channel as the authoritative outcome, which it is not.
    */
   status: "granted";
-  /**
-   * The salted wire digest of the approved task — the same value the matching task-consent/request carried and the decision echoed. The requester already holds it; it is repeated here only so the requester can correlate the notice to the pending task it should now re-submit. It confers nothing: the executor's single-use grant lookup at re-submit is the authorization.
-   */
-  payloadDigest: string;
+  payloadDigest: DigestMultibase;
   /**
    * Type URI of the approved task, for correlation and display at the requester. Advisory on the same terms as the digest — the executor re-derives everything it enforces from the re-submitted payload itself.
    */
@@ -32,7 +34,7 @@ export interface Ext {
 export const TYPE_URI = "https://trusttasks.org/spec/task-consent/granted/0.1" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = TaskConsentGrantedPayload;
+export type Payload = DigestMultibase;
 
 /**
  * SPEC.md §7.2 policy for the request variant, from this specification's

package/src/task-consent/request/0.1/payload.ts

@@ -3,6 +3,11 @@
  * Source: specs/task-consent/request/0.1/payload.schema.json
  */
 
+/**
+ * The binding between what the approver sees and what executes. Multibase-encoded multihash over the RFC 8785 (JCS) canonicalization of the payload, the task type, and the `challenge` as salt. The decision echoes it; the executor re-derives it from the payload it is about to run and refuses on mismatch. Salted because an unsalted digest over a low-entropy payload is a confirmation oracle for anyone who observes it in transit.
+ */
+export type DigestMultibase = string;
+
 /**
  * The executor asks an enrolled approver device to authorize one pending privileged task, presenting the effects it computed by dry-running the real handler against its own prior state. The executor signs this document; the approver renders only what it verifies under that signature.
  */
@@ -15,10 +20,7 @@ export interface TaskConsentRequestPayload {
    * Type URI of the task awaiting approval. It is bound into `payloadDigest`: without that binding, two tasks whose payloads canonicalize identically would share a digest, and an approval for a benign task would authorize a destructive one.
    */
   taskType: string;
-  /**
-   * The binding between what the approver sees and what executes. Digest of the canonical (RFC 8785 JCS) payload, the task type, and the `challenge` as salt. The decision echoes it; the executor re-derives it from the payload it is about to run and refuses on mismatch. Salted because an unsalted digest over a low-entropy payload is a confirmation oracle for anyone who observes it in transit.
-   */
-  payloadDigest: string;
+  payloadDigest: DigestMultibase;
   /**
    * Authoritative SPEC §7.3 item 13 side-effect class of the pending task, derived by the executor from the compiled handler it is about to invoke. NEVER taken from the registry: a registry that decided this would be a consent kill-switch, downgradeable by publishing a new version with a weaker class.
    */
@@ -157,7 +159,7 @@ export interface TaskConsentRequestResponsePayload {
 export const TYPE_URI = "https://trusttasks.org/spec/task-consent/request/0.1" as const;
 
 /** Stable alias for this specification's request payload shape. */
-export type Payload = TaskConsentRequestPayload;
+export type Payload = DigestMultibase;
 
 /** Trust Task response type URI (request type URI + "#response"). */
 export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/task-consent/request/0.1#response" as const;

package/src/trust-task-next-step/0.1/payload.ts

@@ -0,0 +1,95 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/trust-task-next-step/0.1/payload.schema.json
+ */
+
+/**
+ * The recipient-suggested continuation reserved at SPEC.md §8.6: the original task was understood, but cannot complete in isolation, and this names what the recipient party expects in order to proceed.
+ *
+ * A next step is neither a success response nor a failure. The originating task is left open — a consumer that means 'no' returns a trust-task-error instead, and one that means 'done' returns the originating specification's #response variant.
+ *
+ * This specification declares no response anchor: a producer answers a next step by issuing a document of the expected type, not by responding to this one.
+ */
+export interface TrustTaskNextStepPayload {
+  /**
+   * The continuations the recipient will accept, in the producer's order of preference where the recipient has one. More than one entry means ALTERNATIVES — satisfying any single entry unblocks the exchange, never all of them. A recipient that needs several things done first names the one it wants next and issues a further next step afterwards; expressing a conjunction here would be a flow definition, which belongs to a ceremony rather than to a single response.
+   *
+   * @minItems 1
+   */
+  expects: [
+    {
+      /**
+       * The Type URI of the Trust Task the recipient expects next, including any #request fragment. A suggestion only: it confers no authorization to perform that task, and the producer applies its own policy before acting (see the specification's Security & Privacy section).
+       */
+      typeUri: string;
+      /**
+       * Human-readable explanation of why this continuation is expected. Non-normative; intended for operator UI and logs.
+       */
+      reason?: string;
+      /**
+       * Optional structured data the producer MAY use when composing the expected document — a challenge to echo, an identifier to quote, a presentation definition to satisfy. Its shape is governed by the specification named in typeUri, not by this one. A producer MUST NOT treat a hint as authoritative for any value it can determine itself.
+       */
+      hint?: {};
+    },
+    ...{
+      /**
+       * The Type URI of the Trust Task the recipient expects next, including any #request fragment. A suggestion only: it confers no authorization to perform that task, and the producer applies its own policy before acting (see the specification's Security & Privacy section).
+       */
+      typeUri: string;
+      /**
+       * Human-readable explanation of why this continuation is expected. Non-normative; intended for operator UI and logs.
+       */
+      reason?: string;
+      /**
+       * Optional structured data the producer MAY use when composing the expected document — a challenge to echo, an identifier to quote, a presentation definition to satisfy. Its shape is governed by the specification named in typeUri, not by this one. A producer MUST NOT treat a hint as authoritative for any value it can determine itself.
+       */
+      hint?: {};
+    }[]
+  ];
+  /**
+   * What happens once an expected task completes. `resubmit` (the default) means the expected task is a PREREQUISITE and the producer re-issues the originating request to continue — a new document with a fresh id and the same threadId, which SPEC §8.4 distinguishes from a retry, since a retry is bit-for-bit identical and is not what happens here; this matches the established pattern of task-consent/granted, where the requester re-submits once approval lands. `proceed` means the expected task IS the continuation and the originating request is not re-issued, as in an offer answered by a request.
+   */
+  continuation?: "resubmit" | "proceed";
+  /**
+   * Identifies the Trust Task document this next step answers. SHOULD be populated, for the reason SPEC §8.2 gives for the identical member on an error response: threadId correlates the exchange only for a party that already saw the request, so a retained next step otherwise names neither the task it interrupted nor the instance.
+   */
+  inResponseTo?: {
+    /**
+     * The Type URI of the document being answered, including any fragment it carried.
+     */
+    typeUri: string;
+    /**
+     * The id of the specific document being answered (SPEC §4.3). Globally unique and never reused, so it names one instance where threadId names an exchange.
+     */
+    id?: string;
+  };
+  /**
+   * Human-readable description of why the task cannot complete in isolation. Non-normative. Subject to the same restraint as an error message: it reaches a party that may not be entitled to learn why.
+   */
+  message?: string;
+  ext?: Ext;
+}
+/**
+ * Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.
+ */
+export interface Ext {
+  [k: string]: unknown | undefined;
+}
+
+/** Trust Task type URI. */
+export const TYPE_URI = "https://trusttasks.org/spec/trust-task-next-step/0.1" as const;
+
+/** Stable alias for this specification's request payload shape. */
+export type Payload = TrustTaskNextStepPayload;
+
+/**
+ * SPEC.md §7.2 policy for the request variant, from this specification's
+ * front matter. Pass to `consumeInbound` — items 5b, 7 and 8 are
+ * per-specification and cannot be derived from the document alone.
+ */
+export const SPEC = {
+  typeUri: TYPE_URI,
+  isBearer: false,
+  isProofRequired: false,
+  isRecipientRequired: true,
+} as const;

package/src/vta/credentials/issue/0.1/payload.ts

@@ -39,6 +39,8 @@ export interface Ext {
 }
 /**
  * The success response to a vta/credentials/issue request. Carried in a Trust Task document whose type is https://trusttasks.org/spec/vta/credentials/issue/0.1#response.
+ *
+ * This is the credentials/_shared IssuedCredential shape — same members, same required set — plus `supersedes` and `ext`. It states them inline rather than `$ref`-ing the shared definition because that definition sets `additionalProperties: false`, which under `allOf` would reject the two extra members. The shared CredentialId is still referenced. Keep the two in step by hand if either changes.
  */
 export interface VTACredentialsIssueResponsePayload {
   credentialId: CredentialId;

package/src/vta/credentials/issue/0.2/payload.ts

@@ -0,0 +1,101 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/vta/credentials/issue/0.2/payload.schema.json
+ */
+
+/**
+ * The success response to a vta/credentials/issue request. Carried in a Trust Task document whose type is https://trusttasks.org/spec/vta/credentials/issue/0.1#response.
+ *
+ * Composed from the shared IssuedCredential rather than restating it: that definition is the issuance receipt every issuer returns, and duplicating it here let the two drift silently. `unevaluatedProperties` closes the object after the `allOf` is applied, which is what makes the composition possible at all — `additionalProperties` is evaluated per-subschema against the whole object and would reject `supersedes` and `ext`.
+ */
+export type VTACredentialsIssueResponsePayload = IssuedCredentialBase;
+/**
+ * Stable identifier for an issued credential — the handle for revocation and audit. Opaque to the holder: it MUST be echoed verbatim when revoking and MUST NOT be parsed.
+ */
+export type CredentialId = string;
+
+export interface VTACredentialsIssuePayload {
+  /**
+   * DID of the credential's subject/holder (becomes credentialSubject.id).
+   */
+  holder: string;
+  /**
+   * The scoped claims to attest — the share's scope. Opaque to the framework; non-empty.
+   */
+  claims: {};
+  /**
+   * Additional credential type beyond VerifiableCredential (e.g. ScopedShareCredential). Some values name a claims profile defined by this specification (e.g. GovernancePolicyCredential), which constrains the shape of `claims`.
+   */
+  credentialType?: string;
+  /**
+   * Credential lifetime in seconds from issuance. The issuer MAY cap this.
+   */
+  validitySeconds: number;
+  /**
+   * Optional human-readable rationale, recorded for audit.
+   */
+  purpose?: string;
+  ext?: Ext;
+}
+/**
+ * Ecosystem-defined extension members per SPEC.md §4.5.1.
+ */
+export interface Ext {
+  [k: string]: unknown | undefined;
+}
+/**
+ * The members of an issuance receipt, deliberately left **open** so a consuming specification can `$ref` it under `allOf` and add its own, then close the result with `unevaluatedProperties: false`.
+ *
+ * A closure inside this definition would defeat that. Both `additionalProperties` and `unevaluatedProperties` are evaluated against the whole instance from within the subschema that declares them, and neither can see members the *outer* schema matched — so either one here rejects the consumer's extras. Only an `unevaluatedProperties` at the outer level sees everything the composition matched. Use `IssuedCredential` where a closed standalone shape is wanted.
+ */
+export interface IssuedCredentialBase {
+  credentialId: CredentialId;
+  /**
+   * The issued Verifiable Credential (W3C VC Data Model 2.0), signed by the issuer's key. Opaque to the framework.
+   */
+  credential: {};
+  /**
+   * When the credential was minted.
+   */
+  issuedAt?: string;
+  /**
+   * When the credential's validUntil falls due.
+   */
+  expiresAt: string;
+}
+
+/** Trust Task type URI. */
+export const TYPE_URI = "https://trusttasks.org/spec/vta/credentials/issue/0.2" as const;
+
+/** Stable alias for this specification's request payload shape. */
+export type Payload = VTACredentialsIssueResponsePayload;
+
+/** Trust Task response type URI (request type URI + "#response"). */
+export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/vta/credentials/issue/0.2#response" as const;
+
+/** Stable alias for this specification's success-response payload shape. */
+export type Response = VTACredentialsIssueResponsePayload;
+
+/**
+ * SPEC.md §7.2 policy for the request variant, from this specification's
+ * front matter. Pass to `consumeInbound` — items 5b, 7 and 8 are
+ * per-specification and cannot be derived from the document alone.
+ */
+export const SPEC = {
+  typeUri: TYPE_URI,
+  isBearer: false,
+  isProofRequired: true,
+  isRecipientRequired: true,
+} as const;
+
+/**
+ * SPEC.md §7.2 policy for the success-response variant. `isRecipientRequired`
+ * tracks the *issuer* party's requirement because a response swaps the
+ * parties (§7.3 item 5).
+ */
+export const RESPONSE_SPEC = {
+  typeUri: RESPONSE_TYPE_URI,
+  isBearer: false,
+  isProofRequired: true,
+  isRecipientRequired: true,
+} as const;

package/src/vtc/relationships/request/0.1/payload.ts

@@ -0,0 +1,71 @@
+/**
+ * Generated by scripts/build-ts-bindings.mjs — DO NOT EDIT BY HAND.
+ * Source: specs/vtc/relationships/request/0.1/payload.schema.json
+ */
+
+/**
+ * A member asks another member to issue them a Verifiable Relationship Credential. Everything here is a hint: the issuing member decides, and declines with a trust-task-error carrying `vtc/relationships/request:declined` rather than a bespoke rejection message.
+ */
+export interface VTCRelationshipsRequestPayload {
+  /**
+   * Why the requester is asking, in their own words, for the issuing member to weigh. A hint and not a term — the issuing member is under no obligation to honour it, and MUST NOT treat its absence as a defect. Free text reaching a human, so a producer SHOULD keep it to what it is willing to have quoted back.
+   */
+  reason?: string;
+  ext?: Ext;
+}
+/**
+ * Vendor-namespaced extension object per SPEC.md §4.5.1. Each immediate key MUST be a reverse-DNS namespace; structure under each namespace is opaque to the framework.
+ */
+export interface Ext {
+  [k: string]: unknown | undefined;
+}
+/**
+ * The issued credential. Returned only where the issuing member agreed; a decline is a trust-task-error, not a response with an empty field.
+ */
+export interface VTCRelationshipsRequestResponsePayload {
+  /**
+   * A signed W3C Verifiable Relationship Credential (opaque here). Its issuer MUST be the issuing member — the party that signed this response — and its credentialSubject.id MUST name the requester. The same shape `vtc/relationships/publish` accepts, so a requester can lodge it with the community unchanged.
+   */
+  vrc: {};
+  /**
+   * SHA-256 of the returned VRC, for out-of-band integrity checks. Matches the digest `vtc/relationships/publish` reports once the credential is lodged, so the two can be tied together without re-hashing.
+   */
+  vrcSha256?: string;
+  ext?: Ext;
+}
+
+/** Trust Task type URI. */
+export const TYPE_URI = "https://trusttasks.org/spec/vtc/relationships/request/0.1" as const;
+
+/** Stable alias for this specification's request payload shape. */
+export type Payload = VTCRelationshipsRequestPayload;
+
+/** Trust Task response type URI (request type URI + "#response"). */
+export const RESPONSE_TYPE_URI = "https://trusttasks.org/spec/vtc/relationships/request/0.1#response" as const;
+
+/** Stable alias for this specification's success-response payload shape. */
+export type Response = VTCRelationshipsRequestResponsePayload;
+
+/**
+ * SPEC.md §7.2 policy for the request variant, from this specification's
+ * front matter. Pass to `consumeInbound` — items 5b, 7 and 8 are
+ * per-specification and cannot be derived from the document alone.
+ */
+export const SPEC = {
+  typeUri: TYPE_URI,
+  isBearer: false,
+  isProofRequired: true,
+  isRecipientRequired: true,
+} as const;
+
+/**
+ * SPEC.md §7.2 policy for the success-response variant. `isRecipientRequired`
+ * tracks the *issuer* party's requirement because a response swaps the
+ * parties (§7.3 item 5).
+ */
+export const RESPONSE_SPEC = {
+  typeUri: RESPONSE_TYPE_URI,
+  isBearer: false,
+  isProofRequired: true,
+  isRecipientRequired: true,
+} as const;