@phosphorco/bb-identity 0.2.1 → 0.3.0

package/README.md

@@ -463,3 +463,17 @@ lookup decoding. Later conformance must use a packed artifact with two
 independently bundled UI consumers and real upstream→fork→upstream→fork
 sessions. Preserve native content, provider references and upstream grouped-edit
 restrictions in that proof.
+
+## External person attribution V1 (0.3)
+
+`binding.server.externalContributionCapabilities()` synchronously distinguishes an absent capability (`ok(null)`) from a malformed or incompatible host (`ok: false`). A capable host advertises V1, canonical `person` identities, accepted/queued history, and `rollback: 'requires-capable-host'`. This optional subprotocol fits inside outer protocol 1; legacy `sendExternal` and `lookupOperation` retain their existing wire format and hashes.
+
+For a new operation, `sendExternalContribution({version: 1, author, personAttribution}, input)` retains the external Slack/integration origin and an optional canonical person snapshot. The person snapshot contains `identity`, `presentation`, and `evidence: 'integration-asserted'`. It attributes a contribution in a trusted workspace; it conveys no authentication or authorization. Local `default-user` identities are not canonical people.
+
+Persist the exact contribution, operation ID, prompt bytes, and selected transport before dispatch. Capability absence may select legacy external-only attribution for a **new** operation. Never upgrade, downgrade, or rebuild an existing operation from a current directory or mapping. A malformed capability is an incompatibility, not permission to fall back.
+
+V1 receipts confirm the frozen `externalContribution`. Reconcile V1 exclusively through `lookupExternalContribution`, checking its returned attribution against the reservation. Wrong-operation receipts fail validation. Changed or malformed send receipts and exceptions after dispatch are indeterminate. Unknown/unsupported lookup does not authorize resend; only `absent-final` permits the same immutable operation to be retried. Legacy final receipts remain unchanged.
+
+The default host rendering policy adds the integration sender envelope once. A producer such as Rosetta must select `externalMessageRendering: 'producer'` at binding construction; its prompt bytes remain unchanged. A capable native host projects the person into the native timeline while contribution/attempt history keeps the external origin and optional `personAttribution`. This does not add native-message history queries.
+
+Native history containing integration-asserted person authors requires a capable runtime even after queues drain or plugins are downgraded. Do not roll back to a host that only accepts provider-verified person authors. Package-only rollback retains the legacy external path; it does not make old native readers understand newer stored authorship.

package/bb.d.ts

@@ -76,6 +76,9 @@ export interface BbInvocationServer {
   selfProfile(invocation: BbInvocation): Promise<Result<import('./model.js').IdentityProfile>>;
   personRequest(invocation: BbInvocation): Promise<Result<PersonRequest<BbPromptInput>>>;
   readonly sendExternal: IdentityServer<unknown, unknown, BbPromptInput>['sendExternal'];
+  readonly externalContributionCapabilities: IdentityServer<unknown, unknown, BbPromptInput>['externalContributionCapabilities'];
+  readonly sendExternalContribution: IdentityServer<unknown, unknown, BbPromptInput>['sendExternalContribution'];
+  readonly lookupExternalContribution: IdentityServer<unknown, unknown, BbPromptInput>['lookupExternalContribution'];
   readonly lookupOperation: IdentityServer<unknown, unknown, BbPromptInput>['lookupOperation'];
   /** Bounded, validated provenance reads; disposal fences new raw history calls. */
   readonly history: IdentityServer<unknown, unknown, BbPromptInput>['history'];

package/dist/bb-entry-runtime.js

@@ -172,7 +172,7 @@ function isOrigin(value) {
   return value.kind === "unknown" && (value.reason === "legacy" || value.reason === "upstream-unattributed" || value.reason === "missing-source");
 }
 function isContribution(value) {
-  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
+  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
 }
 function isCorrelation(value) {
   return isRecord(value) && idCodec("thread").decode(value.threadId).ok && isBoundedString(value.turnId) && isBoundedString(value.attemptId) && (value.toolCallId === null || isBoundedString(value.toolCallId));
@@ -249,6 +249,17 @@ var provenanceCodec = {
     return value;
   }
 };
+var externalPersonSnapshotCodec = {
+  decode(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !["identity", "presentation", "evidence"].includes(key)) || value.evidence !== "integration-asserted" || !isActorSnapshot(value) || !isRecord(value.identity) || value.identity.kind !== "person" || Object.keys(value.identity).some((key) => !["kind", "key", "issuer", "subject"].includes(key))) {
+      return err("invalid-input", "External person attribution requires a canonical person and integration-asserted evidence.");
+    }
+    return ok(value);
+  },
+  encode(value) {
+    return value;
+  }
+};
 function defaultIdentityKey(instance) {
   return `local:${instance}`;
 }
@@ -766,7 +777,7 @@ function isContribution2(value) {
   if (!isRecord3(origin))
     return false;
   const validOrigin = origin.kind === "person" ? snapshot(origin.actor) && isRecord3(origin.actor) && isPersonIdentity(origin.actor.identity) : origin.kind === "machine" ? snapshot(origin.actor) && isRecord3(origin.actor) && isMachineIdentity(origin.actor.identity) : origin.kind === "external" ? snapshot(origin.actor) && isRecord3(origin.actor) && isExternalIdentity(origin.actor.identity) : origin.kind === "agent" ? origin.agentId === null || idCodec("agent").decode(origin.agentId).ok : origin.kind === "system" ? typeof origin.reason === "string" && origin.reason.length > 0 && origin.reason.length <= 1024 : origin.kind === "unknown" && (origin.reason === "legacy" || origin.reason === "upstream-unattributed" || origin.reason === "missing-source");
-  return validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
+  return (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
 }
 function decodeEvidencePage(value, decodeItem) {
   if (!isRecord3(value) || typeof value.status !== "string")
@@ -1101,6 +1112,7 @@ function createHostAdapter(options) {
     });
     const contexts = new WeakMap;
     return {
+      ...externalContributionMethods(upstream, extension, () => disposed),
       pluginId: upstream.pluginId,
       instanceId: upstream.instanceId,
       session: (context) => upstream.session(context),
@@ -1146,6 +1158,7 @@ function createHostAdapter(options) {
     const error = protocolError(extension);
     const unavailableResult = async () => ({ ok: false, error });
     return {
+      ...externalContributionMethods(upstream, extension, () => disposed),
       pluginId: upstream.pluginId,
       instanceId: upstream.instanceId,
       session: async () => ({ status: error.code === "incompatible" ? "incompatible" : "unavailable", instanceId: upstream.instanceId, error }),
@@ -1221,6 +1234,7 @@ function createHostAdapter(options) {
   });
   const scopes = new WeakMap;
   return {
+    ...externalContributionMethods(upstream, extension, () => disposed),
     pluginId: upstream.pluginId,
     instanceId: protocol.instanceId,
     async session(context) {
@@ -1307,6 +1321,123 @@ function createHostAdapter(options) {
     }
   };
 }
+function decodeExternalContribution(value, strict = true) {
+  if (!isRecord3(value) || value.version !== 1 || !isRecord3(value.author) || strict && Object.keys(value).some((key) => !["version", "author", "personAttribution"].includes(key)) || strict && Object.keys(value.author).some((key) => !["subject", "presentation"].includes(key)) || strict && isRecord3(value.author.presentation) && Object.keys(value.author.presentation).some((key) => !["displayName", "handle", "avatarUrl"].includes(key)) || !idCodec("subject").decode(value.author.subject).ok || !isProfilePresentation(value.author.presentation)) {
+    return err("invalid-input", "Invalid V1 external contribution.");
+  }
+  let person = value.personAttribution;
+  if (!strict && isRecord3(person) && isRecord3(person.identity))
+    person = {
+      identity: { kind: person.identity.kind, key: person.identity.key, issuer: person.identity.issuer, subject: person.identity.subject },
+      presentation: isRecord3(person.presentation) ? { displayName: person.presentation.displayName, handle: person.presentation.handle, avatarUrl: person.presentation.avatarUrl } : person.presentation,
+      evidence: person.evidence
+    };
+  if (strict && isRecord3(person) && isRecord3(person.presentation) && Object.keys(person.presentation).some((key) => !["displayName", "handle", "avatarUrl"].includes(key)))
+    return err("invalid-input", "Unexpected presentation field.");
+  const decoded = person === undefined ? null : externalPersonSnapshotCodec.decode(person);
+  if (decoded && !decoded.ok)
+    return decoded;
+  return ok({
+    version: 1,
+    author: { subject: value.author.subject, presentation: { displayName: value.author.presentation.displayName, handle: value.author.presentation.handle, avatarUrl: value.author.presentation.avatarUrl } },
+    ...decoded?.ok ? { personAttribution: decoded.value } : {}
+  });
+}
+var externalContributionV1Codec = {
+  decode: (value) => decodeExternalContribution(value),
+  encode: (value) => value
+};
+function canonicalExternal(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalExternal).join(",")}]`;
+  if (isRecord3(value))
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalExternal(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function externalContributionMethods(upstream, extension, disposed) {
+  const support = () => {
+    if (disposed())
+      return err("disposed", "Identity host is disposed.");
+    if (extension.status === "absent")
+      return ok(null);
+    if (extension.status !== "supported")
+      return { ok: false, error: protocolError(extension) };
+    const value = extension.protocol.externalContributions;
+    if (value === undefined)
+      return ok(null);
+    if (!isRecord3(value) || !Array.isArray(value.versions) || !value.versions.length || !value.versions.every((version) => Number.isInteger(version) && version > 0))
+      return err("incompatible", "Malformed external contribution capability.");
+    if (!value.versions.includes(1))
+      return ok(null);
+    if (!Array.isArray(value.personKinds) || value.personKinds.length !== 1 || value.personKinds[0] !== "person" || value.history !== "accepted-and-queued" || value.rollback !== "requires-capable-host" || typeof value.acceptV1 !== "function" || typeof value.lookupV1 !== "function")
+      return err("incompatible", "Malformed V1 external contribution capability.");
+    return ok(value);
+  };
+  const outcome = (raw) => {
+    const decoded = decodeAcceptance(raw);
+    if (!decoded.ok || decoded.value.status !== "submitted")
+      return decoded;
+    if (decoded.value.receipt.evidence !== "host-accepted")
+      return err("incompatible", "V1 needs durable native acceptance.");
+    const receipt = decoded.value.receipt;
+    const contribution = decodeExternalContribution(receipt.externalContribution, false);
+    return contribution.ok ? ok({ status: "submitted", receipt: { ...decoded.value.receipt, externalContribution: contribution.value } }) : err("incompatible", "Host receipt omitted or changed V1 attribution.");
+  };
+  return {
+    externalContributionCapabilities() {
+      const negotiated = support();
+      return !negotiated.ok ? negotiated : ok(negotiated.value ? { version: 1, personKinds: ["person"], history: "accepted-and-queued", rollback: "requires-capable-host" } : null);
+    },
+    async sendExternalContribution(contribution, input, options) {
+      const operationId = input.operationId;
+      const decoded = decodeExternalContribution(contribution);
+      if (!decoded.ok)
+        return { status: "rejected", error: decoded.error };
+      const negotiated = support();
+      if (!negotiated.ok)
+        return { status: "rejected", error: negotiated.error };
+      if (!negotiated.value)
+        return { status: "rejected", error: { code: "unsupported", message: "Native external-person attribution V1 is unavailable.", retry: "never" } };
+      if (options?.signal?.aborted)
+        return { status: "rejected", error: { code: "expired", message: "The send was cancelled before dispatch.", retry: "never" } };
+      const frozen = JSON.parse(JSON.stringify(decoded.value));
+      const wire = JSON.parse(JSON.stringify(wireInput(input, upstream.inputCodec)));
+      try {
+        const result = outcome(await negotiated.value.acceptV1({ contribution: frozen, input: wire }, options));
+        if (!result.ok)
+          return { status: "indeterminate", operationId, message: result.error.message };
+        if (result.value.status === "submitted" && (result.value.receipt.operationId !== operationId || canonicalExternal(result.value.receipt.externalContribution) !== canonicalExternal(frozen))) {
+          return { status: "indeterminate", operationId, message: "Host receipt did not confirm the reserved attribution." };
+        }
+        return result.value;
+      } catch {
+        return { status: "indeterminate", operationId, message: "External contribution dispatch outcome is unknown; reconcile this operation." };
+      }
+    },
+    async lookupExternalContribution(operationId, options) {
+      const negotiated = support();
+      if (!negotiated.ok)
+        return negotiated;
+      if (!negotiated.value)
+        return ok({ status: "unknown", reason: "unsupported" });
+      try {
+        const result = asResult(await negotiated.value.lookupV1(operationId, options));
+        if (!result.ok)
+          return result;
+        if (isRecord3(result.value) && result.value.status === "final") {
+          const decoded = outcome(result.value.outcome);
+          if (decoded.ok && decoded.value.status === "submitted" && decoded.value.receipt.operationId !== operationId) {
+            return err("incompatible", "Host lookup returned a receipt for another operation.");
+          }
+          return decoded.ok ? ok({ status: "final", outcome: decoded.value }) : decoded;
+        }
+        return decodeLookup(result.value);
+      } catch {
+        return err("unavailable", "External contribution lookup is unavailable.", "after-reconnect");
+      }
+    }
+  };
+}
 function inspectForkExtension(value) {
   if (value === undefined)
     return { status: "absent" };
@@ -1464,6 +1595,9 @@ function createIdentityServer(options) {
     },
     toolProvenance: (context) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.readToolProvenance(context),
     sendExternal: (author, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternal(author, input, readOptions),
+    externalContributionCapabilities: () => disposed ? err("disposed", "Identity server is disposed.") : host.externalContributionCapabilities(),
+    sendExternalContribution: (contribution, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternalContribution(contribution, input, readOptions),
+    lookupExternalContribution: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupExternalContribution(operationId, readOptions),
     lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupOperation(operationId, readOptions),
     dispose
   };
@@ -2345,6 +2479,17 @@ function createBbIdentityServerBinding(options) {
       const renderedInput = upstream.value.externalMessageRendering === "host" ? renderExternalPrompt(upstream.value.driver.pluginId, author, input.input) : input.input;
       return server.sendExternal(author, { ...input, input: renderedInput }, readOptions);
     },
+    externalContributionCapabilities: () => disposed ? err("disposed", "Identity binding is disposed.") : server.externalContributionCapabilities(),
+    async sendExternalContribution(contribution, input, readOptions) {
+      if (disposed)
+        return { status: "rejected", error: { code: "disposed", message: "Identity binding is disposed.", retry: "never" } };
+      const decoded = externalContributionV1Codec.decode(contribution);
+      if (!decoded.ok)
+        return { status: "rejected", error: decoded.error };
+      const renderedInput = upstream.value.externalMessageRendering === "host" ? renderExternalPrompt(upstream.value.driver.pluginId, decoded.value.author, input.input) : input.input;
+      return server.sendExternalContribution(decoded.value, { ...input, input: renderedInput }, readOptions);
+    },
+    lookupExternalContribution: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity binding is disposed.")) : server.lookupExternalContribution(operationId, readOptions),
     lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity binding is disposed.")) : server.lookupOperation(operationId, readOptions),
     history: guardedHistory
   };

package/dist/host-runtime.js

@@ -107,7 +107,7 @@ function isOrigin(value) {
   return value.kind === "unknown" && (value.reason === "legacy" || value.reason === "upstream-unattributed" || value.reason === "missing-source");
 }
 function isContribution(value) {
-  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
+  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
 }
 function isCorrelation(value) {
   return isRecord(value) && idCodec("thread").decode(value.threadId).ok && isBoundedString(value.turnId) && isBoundedString(value.attemptId) && (value.toolCallId === null || isBoundedString(value.toolCallId));
@@ -184,6 +184,17 @@ var provenanceCodec = {
     return value;
   }
 };
+var externalPersonSnapshotCodec = {
+  decode(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !["identity", "presentation", "evidence"].includes(key)) || value.evidence !== "integration-asserted" || !isActorSnapshot(value) || !isRecord(value.identity) || value.identity.kind !== "person" || Object.keys(value.identity).some((key) => !["kind", "key", "issuer", "subject"].includes(key))) {
+      return err("invalid-input", "External person attribution requires a canonical person and integration-asserted evidence.");
+    }
+    return ok(value);
+  },
+  encode(value) {
+    return value;
+  }
+};
 
 // host-runtime.ts
 function isRecord2(value) {
@@ -375,7 +386,7 @@ function isContribution2(value) {
   if (!isRecord2(origin))
     return false;
   const validOrigin = origin.kind === "person" ? snapshot(origin.actor) && isRecord2(origin.actor) && isPersonIdentity(origin.actor.identity) : origin.kind === "machine" ? snapshot(origin.actor) && isRecord2(origin.actor) && isMachineIdentity(origin.actor.identity) : origin.kind === "external" ? snapshot(origin.actor) && isRecord2(origin.actor) && isExternalIdentity(origin.actor.identity) : origin.kind === "agent" ? origin.agentId === null || idCodec("agent").decode(origin.agentId).ok : origin.kind === "system" ? typeof origin.reason === "string" && origin.reason.length > 0 && origin.reason.length <= 1024 : origin.kind === "unknown" && (origin.reason === "legacy" || origin.reason === "upstream-unattributed" || origin.reason === "missing-source");
-  return validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
+  return (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
 }
 function decodeEvidencePage(value, decodeItem) {
   if (!isRecord2(value) || typeof value.status !== "string")
@@ -710,6 +721,7 @@ function createHostAdapter(options) {
     });
     const contexts = new WeakMap;
     return {
+      ...externalContributionMethods(upstream, extension, () => disposed),
       pluginId: upstream.pluginId,
       instanceId: upstream.instanceId,
       session: (context) => upstream.session(context),
@@ -755,6 +767,7 @@ function createHostAdapter(options) {
     const error = protocolError(extension);
     const unavailableResult = async () => ({ ok: false, error });
     return {
+      ...externalContributionMethods(upstream, extension, () => disposed),
       pluginId: upstream.pluginId,
       instanceId: upstream.instanceId,
       session: async () => ({ status: error.code === "incompatible" ? "incompatible" : "unavailable", instanceId: upstream.instanceId, error }),
@@ -830,6 +843,7 @@ function createHostAdapter(options) {
   });
   const scopes = new WeakMap;
   return {
+    ...externalContributionMethods(upstream, extension, () => disposed),
     pluginId: upstream.pluginId,
     instanceId: protocol.instanceId,
     async session(context) {
@@ -916,6 +930,123 @@ function createHostAdapter(options) {
     }
   };
 }
+function decodeExternalContribution(value, strict = true) {
+  if (!isRecord2(value) || value.version !== 1 || !isRecord2(value.author) || strict && Object.keys(value).some((key) => !["version", "author", "personAttribution"].includes(key)) || strict && Object.keys(value.author).some((key) => !["subject", "presentation"].includes(key)) || strict && isRecord2(value.author.presentation) && Object.keys(value.author.presentation).some((key) => !["displayName", "handle", "avatarUrl"].includes(key)) || !idCodec("subject").decode(value.author.subject).ok || !isProfilePresentation(value.author.presentation)) {
+    return err("invalid-input", "Invalid V1 external contribution.");
+  }
+  let person = value.personAttribution;
+  if (!strict && isRecord2(person) && isRecord2(person.identity))
+    person = {
+      identity: { kind: person.identity.kind, key: person.identity.key, issuer: person.identity.issuer, subject: person.identity.subject },
+      presentation: isRecord2(person.presentation) ? { displayName: person.presentation.displayName, handle: person.presentation.handle, avatarUrl: person.presentation.avatarUrl } : person.presentation,
+      evidence: person.evidence
+    };
+  if (strict && isRecord2(person) && isRecord2(person.presentation) && Object.keys(person.presentation).some((key) => !["displayName", "handle", "avatarUrl"].includes(key)))
+    return err("invalid-input", "Unexpected presentation field.");
+  const decoded = person === undefined ? null : externalPersonSnapshotCodec.decode(person);
+  if (decoded && !decoded.ok)
+    return decoded;
+  return ok({
+    version: 1,
+    author: { subject: value.author.subject, presentation: { displayName: value.author.presentation.displayName, handle: value.author.presentation.handle, avatarUrl: value.author.presentation.avatarUrl } },
+    ...decoded?.ok ? { personAttribution: decoded.value } : {}
+  });
+}
+var externalContributionV1Codec = {
+  decode: (value) => decodeExternalContribution(value),
+  encode: (value) => value
+};
+function canonicalExternal(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalExternal).join(",")}]`;
+  if (isRecord2(value))
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalExternal(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function externalContributionMethods(upstream, extension, disposed) {
+  const support = () => {
+    if (disposed())
+      return err("disposed", "Identity host is disposed.");
+    if (extension.status === "absent")
+      return ok(null);
+    if (extension.status !== "supported")
+      return { ok: false, error: protocolError(extension) };
+    const value = extension.protocol.externalContributions;
+    if (value === undefined)
+      return ok(null);
+    if (!isRecord2(value) || !Array.isArray(value.versions) || !value.versions.length || !value.versions.every((version) => Number.isInteger(version) && version > 0))
+      return err("incompatible", "Malformed external contribution capability.");
+    if (!value.versions.includes(1))
+      return ok(null);
+    if (!Array.isArray(value.personKinds) || value.personKinds.length !== 1 || value.personKinds[0] !== "person" || value.history !== "accepted-and-queued" || value.rollback !== "requires-capable-host" || typeof value.acceptV1 !== "function" || typeof value.lookupV1 !== "function")
+      return err("incompatible", "Malformed V1 external contribution capability.");
+    return ok(value);
+  };
+  const outcome = (raw) => {
+    const decoded = decodeAcceptance(raw);
+    if (!decoded.ok || decoded.value.status !== "submitted")
+      return decoded;
+    if (decoded.value.receipt.evidence !== "host-accepted")
+      return err("incompatible", "V1 needs durable native acceptance.");
+    const receipt = decoded.value.receipt;
+    const contribution = decodeExternalContribution(receipt.externalContribution, false);
+    return contribution.ok ? ok({ status: "submitted", receipt: { ...decoded.value.receipt, externalContribution: contribution.value } }) : err("incompatible", "Host receipt omitted or changed V1 attribution.");
+  };
+  return {
+    externalContributionCapabilities() {
+      const negotiated = support();
+      return !negotiated.ok ? negotiated : ok(negotiated.value ? { version: 1, personKinds: ["person"], history: "accepted-and-queued", rollback: "requires-capable-host" } : null);
+    },
+    async sendExternalContribution(contribution, input, options) {
+      const operationId = input.operationId;
+      const decoded = decodeExternalContribution(contribution);
+      if (!decoded.ok)
+        return { status: "rejected", error: decoded.error };
+      const negotiated = support();
+      if (!negotiated.ok)
+        return { status: "rejected", error: negotiated.error };
+      if (!negotiated.value)
+        return { status: "rejected", error: { code: "unsupported", message: "Native external-person attribution V1 is unavailable.", retry: "never" } };
+      if (options?.signal?.aborted)
+        return { status: "rejected", error: { code: "expired", message: "The send was cancelled before dispatch.", retry: "never" } };
+      const frozen = JSON.parse(JSON.stringify(decoded.value));
+      const wire = JSON.parse(JSON.stringify(wireInput(input, upstream.inputCodec)));
+      try {
+        const result = outcome(await negotiated.value.acceptV1({ contribution: frozen, input: wire }, options));
+        if (!result.ok)
+          return { status: "indeterminate", operationId, message: result.error.message };
+        if (result.value.status === "submitted" && (result.value.receipt.operationId !== operationId || canonicalExternal(result.value.receipt.externalContribution) !== canonicalExternal(frozen))) {
+          return { status: "indeterminate", operationId, message: "Host receipt did not confirm the reserved attribution." };
+        }
+        return result.value;
+      } catch {
+        return { status: "indeterminate", operationId, message: "External contribution dispatch outcome is unknown; reconcile this operation." };
+      }
+    },
+    async lookupExternalContribution(operationId, options) {
+      const negotiated = support();
+      if (!negotiated.ok)
+        return negotiated;
+      if (!negotiated.value)
+        return ok({ status: "unknown", reason: "unsupported" });
+      try {
+        const result = asResult(await negotiated.value.lookupV1(operationId, options));
+        if (!result.ok)
+          return result;
+        if (isRecord2(result.value) && result.value.status === "final") {
+          const decoded = outcome(result.value.outcome);
+          if (decoded.ok && decoded.value.status === "submitted" && decoded.value.receipt.operationId !== operationId) {
+            return err("incompatible", "Host lookup returned a receipt for another operation.");
+          }
+          return decoded.ok ? ok({ status: "final", outcome: decoded.value }) : decoded;
+        }
+        return decodeLookup(result.value);
+      } catch {
+        return err("unavailable", "External contribution lookup is unavailable.", "after-reconnect");
+      }
+    }
+  };
+}
 function inspectForkExtension(value) {
   if (value === undefined)
     return { status: "absent" };
@@ -928,5 +1059,6 @@ function inspectForkExtension(value) {
 export {
   serverSessionCodec,
   inspectForkExtension,
+  externalContributionV1Codec,
   createHostAdapter
 };

package/dist/index-runtime.js

@@ -107,7 +107,7 @@ function isOrigin(value) {
   return value.kind === "unknown" && (value.reason === "legacy" || value.reason === "upstream-unattributed" || value.reason === "missing-source");
 }
 function isContribution(value) {
-  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
+  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
 }
 function isCorrelation(value) {
   return isRecord(value) && idCodec("thread").decode(value.threadId).ok && isBoundedString(value.turnId) && isBoundedString(value.attemptId) && (value.toolCallId === null || isBoundedString(value.toolCallId));
@@ -184,6 +184,17 @@ var provenanceCodec = {
     return value;
   }
 };
+var externalPersonSnapshotCodec = {
+  decode(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !["identity", "presentation", "evidence"].includes(key)) || value.evidence !== "integration-asserted" || !isActorSnapshot(value) || !isRecord(value.identity) || value.identity.kind !== "person" || Object.keys(value.identity).some((key) => !["kind", "key", "issuer", "subject"].includes(key))) {
+      return err("invalid-input", "External person attribution requires a canonical person and integration-asserted evidence.");
+    }
+    return ok(value);
+  },
+  encode(value) {
+    return value;
+  }
+};
 function defaultIdentityKey(instance) {
   return `local:${instance}`;
 }

package/dist/model-runtime.js

@@ -107,7 +107,7 @@ function isOrigin(value) {
   return value.kind === "unknown" && (value.reason === "legacy" || value.reason === "upstream-unattributed" || value.reason === "missing-source");
 }
 function isContribution(value) {
-  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
+  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
 }
 function isCorrelation(value) {
   return isRecord(value) && idCodec("thread").decode(value.threadId).ok && isBoundedString(value.turnId) && isBoundedString(value.attemptId) && (value.toolCallId === null || isBoundedString(value.toolCallId));
@@ -184,6 +184,17 @@ var provenanceCodec = {
     return value;
   }
 };
+var externalPersonSnapshotCodec = {
+  decode(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !["identity", "presentation", "evidence"].includes(key)) || value.evidence !== "integration-asserted" || !isActorSnapshot(value) || !isRecord(value.identity) || value.identity.kind !== "person" || Object.keys(value.identity).some((key) => !["kind", "key", "issuer", "subject"].includes(key))) {
+      return err("invalid-input", "External person attribution requires a canonical person and integration-asserted evidence.");
+    }
+    return ok(value);
+  },
+  encode(value) {
+    return value;
+  }
+};
 function defaultIdentityKey(instance) {
   return `local:${instance}`;
 }
@@ -202,6 +213,7 @@ export {
   newConflictToken,
   identityKeyCodec,
   idCodec,
+  externalPersonSnapshotCodec,
   err,
   defaultIdentityKey
 };

package/dist/server-runtime.js

@@ -187,6 +187,9 @@ function createIdentityServer(options) {
     },
     toolProvenance: (context) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.readToolProvenance(context),
     sendExternal: (author, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternal(author, input, readOptions),
+    externalContributionCapabilities: () => disposed ? err("disposed", "Identity server is disposed.") : host.externalContributionCapabilities(),
+    sendExternalContribution: (contribution, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternalContribution(contribution, input, readOptions),
+    lookupExternalContribution: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupExternalContribution(operationId, readOptions),
     lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupOperation(operationId, readOptions),
     dispose
   };

package/dist/testing-runtime.js

@@ -107,7 +107,7 @@ function isOrigin(value) {
   return value.kind === "unknown" && (value.reason === "legacy" || value.reason === "upstream-unattributed" || value.reason === "missing-source");
 }
 function isContribution(value) {
-  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
+  return isRecord(value) && isContributionReference(value.reference) && isOrigin(value.author) && (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && (value.latestEditor === null || isActorSnapshot(value.latestEditor)) && isBoundedString(value.acceptedAt, 256) && Array.isArray(value.mentionedPeople) && value.mentionedPeople.every(isPersonReference);
 }
 function isCorrelation(value) {
   return isRecord(value) && idCodec("thread").decode(value.threadId).ok && isBoundedString(value.turnId) && isBoundedString(value.attemptId) && (value.toolCallId === null || isBoundedString(value.toolCallId));
@@ -184,6 +184,17 @@ var provenanceCodec = {
     return value;
   }
 };
+var externalPersonSnapshotCodec = {
+  decode(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !["identity", "presentation", "evidence"].includes(key)) || value.evidence !== "integration-asserted" || !isActorSnapshot(value) || !isRecord(value.identity) || value.identity.kind !== "person" || Object.keys(value.identity).some((key) => !["kind", "key", "issuer", "subject"].includes(key))) {
+      return err("invalid-input", "External person attribution requires a canonical person and integration-asserted evidence.");
+    }
+    return ok(value);
+  },
+  encode(value) {
+    return value;
+  }
+};
 function defaultIdentityKey(instance) {
   return `local:${instance}`;
 }
@@ -378,7 +389,7 @@ function isContribution2(value) {
   if (!isRecord2(origin))
     return false;
   const validOrigin = origin.kind === "person" ? snapshot(origin.actor) && isRecord2(origin.actor) && isPersonIdentity(origin.actor.identity) : origin.kind === "machine" ? snapshot(origin.actor) && isRecord2(origin.actor) && isMachineIdentity(origin.actor.identity) : origin.kind === "external" ? snapshot(origin.actor) && isRecord2(origin.actor) && isExternalIdentity(origin.actor.identity) : origin.kind === "agent" ? origin.agentId === null || idCodec("agent").decode(origin.agentId).ok : origin.kind === "system" ? typeof origin.reason === "string" && origin.reason.length > 0 && origin.reason.length <= 1024 : origin.kind === "unknown" && (origin.reason === "legacy" || origin.reason === "upstream-unattributed" || origin.reason === "missing-source");
-  return validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
+  return (value.personAttribution === undefined || externalPersonSnapshotCodec.decode(value.personAttribution).ok) && validOrigin && (value.latestEditor === null || snapshot(value.latestEditor));
 }
 function decodeEvidencePage(value, decodeItem) {
   if (!isRecord2(value) || typeof value.status !== "string")
@@ -713,6 +724,7 @@ function createHostAdapter(options) {
     });
     const contexts = new WeakMap;
     return {
+      ...externalContributionMethods(upstream, extension, () => disposed),
       pluginId: upstream.pluginId,
       instanceId: upstream.instanceId,
       session: (context) => upstream.session(context),
@@ -758,6 +770,7 @@ function createHostAdapter(options) {
     const error = protocolError(extension);
     const unavailableResult = async () => ({ ok: false, error });
     return {
+      ...externalContributionMethods(upstream, extension, () => disposed),
       pluginId: upstream.pluginId,
       instanceId: upstream.instanceId,
       session: async () => ({ status: error.code === "incompatible" ? "incompatible" : "unavailable", instanceId: upstream.instanceId, error }),
@@ -833,6 +846,7 @@ function createHostAdapter(options) {
   });
   const scopes = new WeakMap;
   return {
+    ...externalContributionMethods(upstream, extension, () => disposed),
     pluginId: upstream.pluginId,
     instanceId: protocol.instanceId,
     async session(context) {
@@ -919,6 +933,123 @@ function createHostAdapter(options) {
     }
   };
 }
+function decodeExternalContribution(value, strict = true) {
+  if (!isRecord2(value) || value.version !== 1 || !isRecord2(value.author) || strict && Object.keys(value).some((key) => !["version", "author", "personAttribution"].includes(key)) || strict && Object.keys(value.author).some((key) => !["subject", "presentation"].includes(key)) || strict && isRecord2(value.author.presentation) && Object.keys(value.author.presentation).some((key) => !["displayName", "handle", "avatarUrl"].includes(key)) || !idCodec("subject").decode(value.author.subject).ok || !isProfilePresentation(value.author.presentation)) {
+    return err("invalid-input", "Invalid V1 external contribution.");
+  }
+  let person = value.personAttribution;
+  if (!strict && isRecord2(person) && isRecord2(person.identity))
+    person = {
+      identity: { kind: person.identity.kind, key: person.identity.key, issuer: person.identity.issuer, subject: person.identity.subject },
+      presentation: isRecord2(person.presentation) ? { displayName: person.presentation.displayName, handle: person.presentation.handle, avatarUrl: person.presentation.avatarUrl } : person.presentation,
+      evidence: person.evidence
+    };
+  if (strict && isRecord2(person) && isRecord2(person.presentation) && Object.keys(person.presentation).some((key) => !["displayName", "handle", "avatarUrl"].includes(key)))
+    return err("invalid-input", "Unexpected presentation field.");
+  const decoded = person === undefined ? null : externalPersonSnapshotCodec.decode(person);
+  if (decoded && !decoded.ok)
+    return decoded;
+  return ok({
+    version: 1,
+    author: { subject: value.author.subject, presentation: { displayName: value.author.presentation.displayName, handle: value.author.presentation.handle, avatarUrl: value.author.presentation.avatarUrl } },
+    ...decoded?.ok ? { personAttribution: decoded.value } : {}
+  });
+}
+var externalContributionV1Codec = {
+  decode: (value) => decodeExternalContribution(value),
+  encode: (value) => value
+};
+function canonicalExternal(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalExternal).join(",")}]`;
+  if (isRecord2(value))
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalExternal(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function externalContributionMethods(upstream, extension, disposed) {
+  const support = () => {
+    if (disposed())
+      return err("disposed", "Identity host is disposed.");
+    if (extension.status === "absent")
+      return ok(null);
+    if (extension.status !== "supported")
+      return { ok: false, error: protocolError(extension) };
+    const value = extension.protocol.externalContributions;
+    if (value === undefined)
+      return ok(null);
+    if (!isRecord2(value) || !Array.isArray(value.versions) || !value.versions.length || !value.versions.every((version) => Number.isInteger(version) && version > 0))
+      return err("incompatible", "Malformed external contribution capability.");
+    if (!value.versions.includes(1))
+      return ok(null);
+    if (!Array.isArray(value.personKinds) || value.personKinds.length !== 1 || value.personKinds[0] !== "person" || value.history !== "accepted-and-queued" || value.rollback !== "requires-capable-host" || typeof value.acceptV1 !== "function" || typeof value.lookupV1 !== "function")
+      return err("incompatible", "Malformed V1 external contribution capability.");
+    return ok(value);
+  };
+  const outcome = (raw) => {
+    const decoded = decodeAcceptance(raw);
+    if (!decoded.ok || decoded.value.status !== "submitted")
+      return decoded;
+    if (decoded.value.receipt.evidence !== "host-accepted")
+      return err("incompatible", "V1 needs durable native acceptance.");
+    const receipt = decoded.value.receipt;
+    const contribution = decodeExternalContribution(receipt.externalContribution, false);
+    return contribution.ok ? ok({ status: "submitted", receipt: { ...decoded.value.receipt, externalContribution: contribution.value } }) : err("incompatible", "Host receipt omitted or changed V1 attribution.");
+  };
+  return {
+    externalContributionCapabilities() {
+      const negotiated = support();
+      return !negotiated.ok ? negotiated : ok(negotiated.value ? { version: 1, personKinds: ["person"], history: "accepted-and-queued", rollback: "requires-capable-host" } : null);
+    },
+    async sendExternalContribution(contribution, input, options) {
+      const operationId = input.operationId;
+      const decoded = decodeExternalContribution(contribution);
+      if (!decoded.ok)
+        return { status: "rejected", error: decoded.error };
+      const negotiated = support();
+      if (!negotiated.ok)
+        return { status: "rejected", error: negotiated.error };
+      if (!negotiated.value)
+        return { status: "rejected", error: { code: "unsupported", message: "Native external-person attribution V1 is unavailable.", retry: "never" } };
+      if (options?.signal?.aborted)
+        return { status: "rejected", error: { code: "expired", message: "The send was cancelled before dispatch.", retry: "never" } };
+      const frozen = JSON.parse(JSON.stringify(decoded.value));
+      const wire = JSON.parse(JSON.stringify(wireInput(input, upstream.inputCodec)));
+      try {
+        const result = outcome(await negotiated.value.acceptV1({ contribution: frozen, input: wire }, options));
+        if (!result.ok)
+          return { status: "indeterminate", operationId, message: result.error.message };
+        if (result.value.status === "submitted" && (result.value.receipt.operationId !== operationId || canonicalExternal(result.value.receipt.externalContribution) !== canonicalExternal(frozen))) {
+          return { status: "indeterminate", operationId, message: "Host receipt did not confirm the reserved attribution." };
+        }
+        return result.value;
+      } catch {
+        return { status: "indeterminate", operationId, message: "External contribution dispatch outcome is unknown; reconcile this operation." };
+      }
+    },
+    async lookupExternalContribution(operationId, options) {
+      const negotiated = support();
+      if (!negotiated.ok)
+        return negotiated;
+      if (!negotiated.value)
+        return ok({ status: "unknown", reason: "unsupported" });
+      try {
+        const result = asResult(await negotiated.value.lookupV1(operationId, options));
+        if (!result.ok)
+          return result;
+        if (isRecord2(result.value) && result.value.status === "final") {
+          const decoded = outcome(result.value.outcome);
+          if (decoded.ok && decoded.value.status === "submitted" && decoded.value.receipt.operationId !== operationId) {
+            return err("incompatible", "Host lookup returned a receipt for another operation.");
+          }
+          return decoded.ok ? ok({ status: "final", outcome: decoded.value }) : decoded;
+        }
+        return decodeLookup(result.value);
+      } catch {
+        return err("unavailable", "External contribution lookup is unavailable.", "after-reconnect");
+      }
+    }
+  };
+}
 function inspectForkExtension(value) {
   if (value === undefined)
     return { status: "absent" };
@@ -2187,6 +2318,9 @@ function createIdentityServer(options) {
     },
     toolProvenance: (context) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.readToolProvenance(context),
     sendExternal: (author, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternal(author, input, readOptions),
+    externalContributionCapabilities: () => disposed ? err("disposed", "Identity server is disposed.") : host.externalContributionCapabilities(),
+    sendExternalContribution: (contribution, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternalContribution(contribution, input, readOptions),
+    lookupExternalContribution: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupExternalContribution(operationId, readOptions),
     lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupOperation(operationId, readOptions),
     dispose
   };
@@ -2708,6 +2842,17 @@ function createBbIdentityServerBinding(options) {
       const renderedInput = upstream.value.externalMessageRendering === "host" ? renderExternalPrompt(upstream.value.driver.pluginId, author, input.input) : input.input;
       return server.sendExternal(author, { ...input, input: renderedInput }, readOptions);
     },
+    externalContributionCapabilities: () => disposed ? err("disposed", "Identity binding is disposed.") : server.externalContributionCapabilities(),
+    async sendExternalContribution(contribution, input, readOptions) {
+      if (disposed)
+        return { status: "rejected", error: { code: "disposed", message: "Identity binding is disposed.", retry: "never" } };
+      const decoded = externalContributionV1Codec.decode(contribution);
+      if (!decoded.ok)
+        return { status: "rejected", error: decoded.error };
+      const renderedInput = upstream.value.externalMessageRendering === "host" ? renderExternalPrompt(upstream.value.driver.pluginId, decoded.value.author, input.input) : input.input;
+      return server.sendExternalContribution(decoded.value, { ...input, input: renderedInput }, readOptions);
+    },
+    lookupExternalContribution: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity binding is disposed.")) : server.lookupExternalContribution(operationId, readOptions),
     lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity binding is disposed.")) : server.lookupOperation(operationId, readOptions),
     history: guardedHistory
   };

package/host.d.ts

@@ -37,6 +37,29 @@ export type HostInvalidation =
   | { readonly kind: 'participants'; readonly threadIds: readonly string[] }
   | { readonly kind: 'disconnected' | 'reconnected' | 'disposed' };
 export interface ExternalAuthorInput { readonly subject: string; readonly presentation: ProfilePresentation; }
+export interface ExternalContributionV1 {
+  readonly version: 1;
+  readonly author: ExternalAuthorInput;
+  readonly personAttribution?: import('./model.js').ExternalPersonSnapshotV1;
+}
+export declare const externalContributionV1Codec: Codec<ExternalContributionV1>;
+export type ExternalContributionOutcomeV1 = Exclude<AcceptanceOutcome, { status: 'submitted' }> | {
+  readonly status: 'submitted';
+  readonly receipt: Extract<import('./model.js').AcceptanceReceipt, { evidence: 'host-accepted' }> & {
+    readonly externalContribution: ExternalContributionV1;
+  };
+};
+/** Context-free support; native storage written by V1 requires a capable host on rollback. */
+export interface ExternalContributionCapabilityV1 {
+  readonly version: 1; readonly personKinds: readonly ['person'];
+  readonly history: 'accepted-and-queued'; readonly rollback: 'requires-capable-host';
+}
+export interface ExternalContributionProtocolV1<Input> {
+  readonly versions: readonly number[]; readonly personKinds: readonly ['person'];
+  readonly history: 'accepted-and-queued'; readonly rollback: 'requires-capable-host';
+  acceptV1(request: { readonly contribution: Wire<ExternalContributionV1>; readonly input: Wire<SendInput<Input>> }, options?: ReadOptions): Promise<Wire<ExternalContributionOutcomeV1>>;
+  lookupV1(operationId: string, options?: ReadOptions): Promise<Wire<Result<OperationLookup<ExternalContributionOutcomeV1>>>>;
+}
 export interface IdentityHost<RequestContext, ToolContext, Input> extends Disposable {
   readonly pluginId: PluginId;
   readonly instanceId: InstanceId;
@@ -51,6 +74,10 @@ export interface IdentityHost<RequestContext, ToolContext, Input> extends Dispos
   /** Checks synchronously before upstream dispatch; enhanced host checks again inside acceptance. */
   send(request: LiveRequest, input: SendInput<Input>, options?: ReadOptions): Promise<AcceptanceOutcome>;
   sendExternal(author: ExternalAuthorInput, input: SendInput<Input>, options?: ReadOptions): Promise<AcceptanceOutcome>;
+  externalContributionCapabilities(): Result<ExternalContributionCapabilityV1 | null>;
+  sendExternalContribution(contribution: ExternalContributionV1, input: SendInput<Input>, options?: ReadOptions): Promise<ExternalContributionOutcomeV1>;
+  lookupExternalContribution(operationId: SendInput<Input>['operationId'], options?: ReadOptions): Promise<Result<OperationLookup<ExternalContributionOutcomeV1>>>;
+
   lookupOperation(operationId: SendInput<Input>['operationId'], options?: ReadOptions): Promise<Result<OperationLookup<AcceptanceOutcome>>>;
   forward(request: LiveRequest, destinationPlugin: string, method: string, input: import('./model.js').Json): Promise<unknown>;
   registerProvider(provider: IdentityProvider): Promise<Result<ProviderRegistrationV1>>;
@@ -149,6 +176,7 @@ export interface ForkIdentityProvider {
 /** Core implements these host-owned operations, not IdentityHost's fallback/directory composition. */
 export interface ForkIdentityProtocolV1<RequestContext, ToolContext, Input> {
   readonly version: 1;
+  readonly externalContributions?: ExternalContributionProtocolV1<Input>;
   /** Persisted core storage namespace; stable across plugin replacement and never request-derived. */
   readonly instanceId: string;
   /** Enables this plugin generation's producer-owned external message rendering in the SDK host. */

package/model.d.ts

@@ -99,10 +99,17 @@ export interface ContributionReference {
   readonly threadId: ThreadId;
   readonly contributionId: ContributionId;
 }
+/** Frozen integration assertion; V1 supports canonical people, not default-user. */
+export type ExternalPersonSnapshotV1 = ActorSnapshot & {
+  readonly identity: Extract<IdentityReference, { kind: 'person' }>;
+  readonly evidence: 'integration-asserted';
+};
+export declare const externalPersonSnapshotCodec: Codec<ExternalPersonSnapshotV1>;
 /** A contribution is independent of delivery grouping and execution attempts. */
 export interface Contribution {
   readonly reference: ContributionReference;
   readonly author: Origin;
+  readonly personAttribution?: ExternalPersonSnapshotV1;
   readonly latestEditor: ActorSnapshot | null;
   readonly acceptedAt: string;
   readonly mentionedPeople: readonly PersonReference[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phosphorco/bb-identity",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "description": "Portable identity, provenance, and state contracts for BB integrations.",

package/server.d.ts

@@ -2,7 +2,7 @@
 import type { AcceptanceOutcome, ActorReference, ActorSnapshot, Codec, Directory, Disposable, ExecutionProvenance,
   IdentityKey, InstanceId, OperationId, OperationLookup, ParticipantReader, PersonReference,
   PersonSendInput, ReadOptions, RequestExpectation, Result, SendInput, TargetSelection, Unsubscribe } from './model.js';
-import type { ExternalAuthorInput, IdentityHost, IdentityCapabilities, ServerSession, HostInvalidation } from './host.js';
+import type { ExternalAuthorInput, ExternalContributionV1, ExternalContributionOutcomeV1, ExternalContributionCapabilityV1, IdentityHost, IdentityCapabilities, ServerSession, HostInvalidation } from './host.js';
 
 declare const resolvedTarget: unique symbol;
 export interface TargetSnapshot {
@@ -61,6 +61,10 @@ export interface IdentityServer<RequestContext, ToolContext, Input> extends Disp
   personRequest(context: RequestContext, options?: ReadOptions): Promise<Result<PersonRequest<Input>>>;
   toolProvenance(context: ToolContext): Promise<Result<ExecutionProvenance>>;
   sendExternal(author: ExternalAuthorInput, input: SendInput<Input>, options?: ReadOptions): Promise<AcceptanceOutcome>;
+  externalContributionCapabilities(): Result<ExternalContributionCapabilityV1 | null>;
+  sendExternalContribution(contribution: ExternalContributionV1, input: SendInput<Input>, options?: ReadOptions): Promise<ExternalContributionOutcomeV1>;
+  lookupExternalContribution(operationId: SendInput<Input>['operationId'], options?: ReadOptions): Promise<Result<OperationLookup<ExternalContributionOutcomeV1>>>;
+
   /** Lookup reports retained operation outcomes; IDs are scoped to this instance/plugin. */
   lookupOperation(operationId: OperationId, options?: ReadOptions): Promise<Result<OperationLookup<AcceptanceOutcome>>>;
 }