@evomap/evolver-adapter-public 2.0.0-beta.14 → 2.0.0-beta.16

package/dist/hubCapability.d.ts

@@ -8,6 +8,8 @@ export declare const PUBLIC_PROTOCOL_VERSION = "gep-a2a/1.0.0";
 export declare const PUBLIC_HUB_CAPABILITIES: hub.HubCapabilityName[];
 export declare const USED_ASSET_IDS_MAX = 50;
 export declare const USED_ASSET_ID_MAX_LEN = 200;
+export declare const LEARNING_ASSET_IDS_MAX = 50;
+export declare const LEARNING_ASSET_ID_MAX_LEN = 128;
 /**
  * An outcome the agent reports back to the hub's memory graph after a cycle.
  * `usedAssetIds` is the fetch->outcome attribution claim: which hub assets the
@@ -159,6 +161,8 @@ export declare class PublicHubCapability implements hub.HubCapability {
     recordOutcome(report: OutcomeReport): Promise<OutcomeReceipt>;
     recordMemoryEvent(report: MemoryGraphEventReport): Promise<MemoryGraphEventReceipt>;
     recordReuseResult(report: hub.ReuseResultReport): Promise<hub.ReuseResultReceipt>;
+    listLearningAssets(options?: hub.LearningAssetListOptions): Promise<hub.LearningAssetListResult>;
+    recordLearningAssetUsage(report: hub.LearningAssetUsageReport): Promise<hub.LearningAssetUsageReceipt>;
     /**
      * Pre-publish dry-run (POST /a2a/validate). The hub runs the same hub-side quality +
      * content-safety gate as publish but stores nothing and charges no credits. This adapter is
@@ -171,7 +175,7 @@ export declare class PublicHubCapability implements hub.HubCapability {
      */
     validate(bundle: hub.AssetRecord[]): Promise<hub.ValidateReceipt>;
     createRecipe(request: hub.RecipeCreateRequest): Promise<hub.RecipeReceipt>;
-    publishRecipe(recipeId: string): Promise<hub.RecipeReceipt>;
+    publishRecipe(recipeId: string, options?: hub.RecipePublishOptions): Promise<hub.RecipeReceipt>;
     getRecipe(recipeId: string): Promise<hub.RecipeFetchReceipt>;
     expressRecipe(recipeId: string, request?: hub.RecipeExpressRequest): Promise<hub.RecipeExpressionReceipt>;
     task: {

package/dist/hubCapability.js

@@ -9,7 +9,7 @@ export const INBOUND_LIMIT = 100;
 export const OUTBOUND_MAX_BATCH = 50;
 export const OUTBOUND_MAX_BODY_BYTES = 4 * 1024 * 1024;
 export const PUBLIC_PROTOCOL_VERSION = 'gep-a2a/1.0.0';
-export const PUBLIC_HUB_CAPABILITIES = ['publish', 'fetch', 'search', 'task', 'mailbox', 'auth', 'marketplace', 'economy', 'questions', 'recipes', 'agent_directory'];
+export const PUBLIC_HUB_CAPABILITIES = ['publish', 'fetch', 'search', 'task', 'mailbox', 'auth', 'marketplace', 'economy', 'questions', 'recipes', 'agent_directory', 'learning_assets'];
 const QUESTION_SUBMIT_FAST_PATH_BYPASS_CONTENT_HASH = 'sha256:0000000000000000000000000000000000000000000000000000000000000000';
 const DRY_RUN_RECIPE_ID = 'dry-run-recipe';
 const HUB_DRY_RUN_VALUES = new Set(['1', 'true', 'yes', 'on']);
@@ -18,6 +18,8 @@ const HUB_DRY_RUN_VALUES = new Set(['1', 'true', 'yes', 'on']);
 // equals what the hub will KEEP.
 export const USED_ASSET_IDS_MAX = 50;
 export const USED_ASSET_ID_MAX_LEN = 200;
+export const LEARNING_ASSET_IDS_MAX = 50;
+export const LEARNING_ASSET_ID_MAX_LEN = 128;
 /** 完整 GEP-A2A 信封(实测 dev: publish/fetch/validate 等协议消息端点必须全信封, 非仅 protocol+message_type). */
 export function gepEnvelope(messageType, payload) {
     return {
@@ -83,7 +85,7 @@ export class PublicHubCapability {
     auth;
     recipes = {
         create: async (request) => this.createRecipe(request),
-        publish: async (recipeId) => this.publishRecipe(recipeId),
+        publish: async (recipeId, options) => this.publishRecipe(recipeId, options),
         get: async (recipeId) => this.getRecipe(recipeId),
         express: async (recipeId, request = {}) => this.expressRecipe(recipeId, request),
     };
@@ -402,6 +404,52 @@ export class PublicHubCapability {
             return { recorded: false, reason: e instanceof Error ? e.message : String(e) };
         }
     }
+    async listLearningAssets(options = {}) {
+        const limit = normalizeLearningAssetLimit(options.limit);
+        if (!this.opts.senderId()?.trim())
+            return { assets: [], limit, reason: 'sender_id_required' };
+        try {
+            const body = await this.http.call('GET', '/a2a/learning-assets', undefined, learningAssetListQuery(options, limit));
+            const payload = asRecord(body['payload']) ?? body;
+            return {
+                assets: learningAssetsFromPayload(payload),
+                limit: numberField(payload, 'limit') ?? limit,
+            };
+        }
+        catch (e) {
+            return { assets: [], limit, reason: failureReason(e) };
+        }
+    }
+    async recordLearningAssetUsage(report) {
+        if (!this.opts.senderId()?.trim())
+            return { recorded: false, reason: 'sender_id_required', results: [] };
+        const sourceEventId = trimStringField(report.sourceEventId, 160);
+        if (!sourceEventId)
+            return { recorded: false, reason: 'source_event_id_required', results: [] };
+        const assetIds = normalizeLearningAssetIds(report.usedAssetIds && report.usedAssetIds.length > 0 ? report.usedAssetIds : [report.assetId]);
+        if (assetIds.length === 0)
+            return { recorded: false, reason: 'asset_id_required', results: [] };
+        const outcome = normalizeLearningAssetOutcome(report.outcome);
+        if (!outcome)
+            return { recorded: false, reason: 'invalid_learning_asset_outcome', results: [] };
+        const score = optionalLearningAssetScore(report.score);
+        if ('reason' in score)
+            return { recorded: false, reason: score.reason, results: [] };
+        const reason = trimStringField(report.reason, 2_000);
+        try {
+            const body = await this.http.call('POST', '/a2a/learning-assets/usage', {
+                ...(assetIds.length === 1 ? { asset_id: assetIds[0] } : { used_asset_ids: assetIds }),
+                outcome,
+                source_event_id: sourceEventId,
+                ...(score.value !== undefined ? { score: score.value } : {}),
+                ...(reason ? { reason } : {}),
+            });
+            return learningAssetUsageReceiptFromBody(body);
+        }
+        catch (e) {
+            return { recorded: false, reason: failureReason(e), results: [] };
+        }
+    }
     /**
      * Pre-publish dry-run (POST /a2a/validate). The hub runs the same hub-side quality +
      * content-safety gate as publish but stores nothing and charges no credits. This adapter is
@@ -457,14 +505,14 @@ export class PublicHubCapability {
             ...(request.pricePerExecution !== undefined ? { price_per_execution: request.pricePerExecution } : {}),
             ...(request.currency ? { currency: request.currency } : {}),
             ...(request.maxConcurrent !== undefined ? { max_concurrent: request.maxConcurrent } : {}),
-        });
+        }, undefined, request.idempotencyKey ? { 'idempotency-key': request.idempotencyKey } : undefined);
         return recipeReceiptFromBody(body);
     }
-    async publishRecipe(recipeId) {
+    async publishRecipe(recipeId, options) {
         if (isHubDryRunEnabled())
             return dryRunRecipeReceipt('publish_recipe', recipeId);
         const sender = this.opts.senderId();
-        const body = await this.http.call('POST', `/a2a/recipe/${encodeURIComponent(recipeId)}/publish`, { ...(sender ? { node_id: sender } : {}) });
+        const body = await this.http.call('POST', `/a2a/recipe/${encodeURIComponent(recipeId)}/publish`, { ...(sender ? { node_id: sender } : {}) }, undefined, options?.idempotencyKey ? { 'idempotency-key': options.idempotencyKey } : undefined);
         return recipeReceiptFromBody(body);
     }
     async getRecipe(recipeId) {
@@ -765,6 +813,105 @@ function accountAssetsFromPayload(payload) {
     }
     return [];
 }
+function learningAssetsFromPayload(payload) {
+    const candidates = [
+        payload['assets'],
+        payload['results'],
+        payload['items'],
+    ];
+    for (const candidate of candidates) {
+        if (!Array.isArray(candidate))
+            continue;
+        return candidate.filter((asset) => isLearningAssetRecord(asset));
+    }
+    return [];
+}
+function isLearningAssetRecord(value) {
+    const record = asRecord(value);
+    return Boolean(record && typeof record['asset_id'] === 'string' && typeof record['type'] === 'string');
+}
+function normalizeLearningAssetLimit(value) {
+    if (!Number.isFinite(value))
+        return 20;
+    return Math.min(100, Math.max(1, Math.floor(value)));
+}
+function learningAssetListQuery(options, limit) {
+    const status = normalizeLearningAssetStatusParam(options.status);
+    const query = {
+        limit,
+        runtime: options.includeExpired === true ? undefined : 'true',
+        include_expired: options.includeExpired === true ? 'true' : undefined,
+        include_payload: options.includePayload === true ? 'true' : undefined,
+        ...(options.type ? { type: options.type } : {}),
+        ...(status ? { status } : options.includeExpired === true ? { status: 'active' } : {}),
+    };
+    const scope = compactLearningAssetParam(options.scope);
+    if (scope)
+        query['scope'] = scope;
+    return query;
+}
+function normalizeLearningAssetStatusParam(status) {
+    if (Array.isArray(status))
+        return compactLearningAssetParam(status);
+    return typeof status === 'string' && status.trim() ? status.trim() : undefined;
+}
+function compactLearningAssetParam(values) {
+    if (!values)
+        return undefined;
+    const out = [...new Set(values.map((value) => String(value).trim()).filter(Boolean))];
+    return out.length > 0 ? out.join(',') : undefined;
+}
+function trimStringField(value, maxLen) {
+    return typeof value === 'string' && value.trim() ? value.trim().slice(0, maxLen) : undefined;
+}
+function normalizeLearningAssetIds(values) {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (typeof value !== 'string')
+            continue;
+        const trimmed = value.trim();
+        if (!trimmed || trimmed.length > LEARNING_ASSET_ID_MAX_LEN || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+        if (out.length >= LEARNING_ASSET_IDS_MAX)
+            break;
+    }
+    return out;
+}
+function normalizeLearningAssetOutcome(value) {
+    if (value === 'success' || value === 'failed' || value === 'mismatched' || value === 'stale' || value === 'unsafe')
+        return value;
+    return undefined;
+}
+function optionalLearningAssetScore(value) {
+    if (value === undefined)
+        return { value: undefined };
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1)
+        return { reason: 'invalid_score' };
+    return { value };
+}
+function learningAssetUsageReceiptFromBody(body) {
+    const payload = asRecord(body['payload']) ?? body;
+    const rows = Array.isArray(payload['results'])
+        ? payload['results'].filter((row) => Boolean(asRecord(row)))
+        : [];
+    const reason = stringField(payload, 'reason') ?? stringField(payload, 'error');
+    return {
+        recorded: rows.length > 0 && rows.some((row) => row.recorded === true),
+        ...(reason ? { reason } : {}),
+        results: rows,
+    };
+}
+function failureReason(error) {
+    if (error instanceof HubClientError) {
+        const body = asRecord(error.body) ?? {};
+        const payload = asRecord(body['payload']) ?? body;
+        return stringField(payload, 'reason') ?? stringField(payload, 'error') ?? `hub ${error.status}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
 function assetMatchesId(asset, assetId) {
     return Boolean(asset && (asset.asset_id === assetId || stringField(asset, 'id') === assetId));
 }

package/dist/hubFetch.d.ts

@@ -69,7 +69,7 @@ export interface HubFetchDeps {
 export declare class HubFetch {
     private readonly deps;
     constructor(deps: HubFetchDeps);
-    call<T>(method: string, path: string, bodyObj?: Record<string, unknown>, query?: Record<string, string | number | undefined>): Promise<T>;
+    call<T>(method: string, path: string, bodyObj?: Record<string, unknown>, query?: Record<string, string | number | undefined>, requestHeaders?: Readonly<Record<string, string>>): Promise<T>;
 }
 export declare function hubResponseContentType(res: Pick<HubFetchResponse, 'headers'> | undefined): string;
 export declare function isHubApiResponse(res: Pick<HubFetchResponse, 'headers'> | undefined): boolean;

package/dist/hubFetch.js

@@ -40,6 +40,24 @@ export class HubUnreachableError extends Error {
         return this.details.retryAfterMs ?? HUB_UNREACHABLE_BACKOFF_BASE_MS;
     }
 }
+const PROTECTED_REQUEST_HEADERS = new Set([
+    'authorization',
+    'content-type',
+    'x-evomap-node-secret-version',
+    'x-evomap-signature',
+    'x-node-secret',
+]);
+function mergeRequestHeaders(requestHeaders, signedHeaders) {
+    const signedNames = new Set(Object.keys(signedHeaders ?? {}).map((name) => name.toLowerCase()));
+    const headers = {};
+    for (const [name, value] of Object.entries(requestHeaders ?? {})) {
+        const normalized = name.toLowerCase();
+        if (!PROTECTED_REQUEST_HEADERS.has(normalized) && !signedNames.has(normalized))
+            headers[normalized] = value;
+    }
+    headers['content-type'] = 'application/json';
+    return { ...headers, ...signedHeaders };
+}
 /**
  * 公版 hub HTTP 客户端(M6-6). 每请求经 AuthProvider 取凭证: POST 通常注入 body; GET 与 strict hello envelope
  * 走 **Authorization: Bearer <node_secret>** 头(hub 只从 header/body 读 node_secret, 绝不从 query — #8);
@@ -52,7 +70,7 @@ export class HubFetch {
     constructor(deps) {
         this.deps = deps;
     }
-    async call(method, path, bodyObj, query) {
+    async call(method, path, bodyObj, query, requestHeaders) {
         const draft = bodyObj !== undefined ? JSON.stringify(bodyObj) : '';
         const signed = await this.deps.auth.authenticate({ method, path, ...(draft ? { body: draft } : {}) });
         const sender = this.deps.senderId();
@@ -60,7 +78,7 @@ export class HubFetch {
         let url = `${this.deps.baseUrl}${path}`;
         assertHubUrlSecure(url); // request-level scheme guard (defense in depth): even a misconfigured injected fetchFn cannot egress in plaintext
         let body;
-        const headers = { 'content-type': 'application/json', ...signed.headers };
+        const headers = mergeRequestHeaders(requestHeaders, signed.headers);
         if (method === 'GET') {
             const qs = new URLSearchParams();
             if (sender)

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './antiAbuseTelemetry.js';
 export * from './offlinePermit.js';
 export * from './hubReuse.js';
 export * from './hubUrl.js';
+export * from './learningPacketSink.js';
 export * from './atp.js';
 export * from './pricing/modelPrices.js';
 export * from './connect.js';

package/dist/index.js

@@ -14,6 +14,7 @@ export * from './antiAbuseTelemetry.js';
 export * from './offlinePermit.js';
 export * from './hubReuse.js';
 export * from './hubUrl.js';
+export * from './learningPacketSink.js';
 export * from './atp.js';
 export * from './pricing/modelPrices.js';
 export * from './connect.js';

package/dist/learningPacketSink.d.ts

@@ -0,0 +1,34 @@
+import type { hub, trace } from '@evomap/evolver-core';
+import { type FetchLike } from './hubFetch.js';
+/** Hub traceEvents array cap (createLearningPacketSchema). Extra events are dropped, noted in metadata. */
+export declare const HUB_TRACE_EVENTS_MAX = 100;
+export interface HubLearningPacketSinkOptions {
+    baseUrl: string;
+    auth: hub.AuthProvider;
+    fetchFn: FetchLike;
+    /** Optional node identity recorded on the packet (hub nodeId column). */
+    nodeId?: () => string | undefined;
+}
+/** Deterministic content hash over the draft body (hub contentHash column, dedup aid). */
+export declare function learningPacketContentHash(draft: trace.LearningPacketDraft): string;
+/** Map a core draft to the hub createLearningPacket body. Exported for tests and for the private adapter to reuse. */
+export declare function learningPacketWireBody(draft: trace.LearningPacketDraft, nodeId?: string): Record<string, unknown>;
+/**
+ * LearningPacketSink implementation against the public hub Learning Ops ingest API. Best-effort by
+ * contract: every failure returns { accepted: false, reason } (never throws) — the runtime treats packet
+ * delivery as observability, so a hub outage must never affect a task verdict. A 409 duplicate_source is
+ * reported as accepted (the packet is already there; the idempotency key did its job).
+ */
+export declare class HubLearningPacketSink implements trace.LearningPacketSink {
+    private readonly opts;
+    constructor(opts: HubLearningPacketSinkOptions);
+    submit(draft: trace.LearningPacketDraft): Promise<trace.LearningPacketSubmitResult>;
+}
+/** Fan-out: always deliver to `primary` (local file record), then best-effort to `secondary` (hub upload).
+ *  The composite result reflects the PRIMARY sink — the local record is the durability guarantee. */
+export declare class TeeLearningPacketSink implements trace.LearningPacketSink {
+    private readonly primary;
+    private readonly secondary;
+    constructor(primary: trace.LearningPacketSink, secondary: trace.LearningPacketSink);
+    submit(draft: trace.LearningPacketDraft): Promise<trace.LearningPacketSubmitResult>;
+}

package/dist/learningPacketSink.js

@@ -0,0 +1,142 @@
+// Learning Ops packet upload (slice 3) — the adapter half of core's LearningPacketSink port.
+// Maps a local LearningPacketDraft (learning_packet.v0, built by evolver-core/trace) onto the hub's
+// `POST /api/learning-packets` ingest contract (strict zod schema, requireAuth Bearer token).
+//
+// Deliberately NOT built on HubFetch: that helper injects sender_id/credential fields into every POST body
+// (the /a2a envelope convention), which the strict learning-packets schema rejects. This sink authenticates
+// via the injected AuthProvider (Authorization header only) and sends exactly the schema's fields.
+import { createHash } from 'node:crypto';
+import { assertHubUrlSecure, isHubUnreachableError } from './hubFetch.js';
+/** Hub traceEvents array cap (createLearningPacketSchema). Extra events are dropped, noted in metadata. */
+export const HUB_TRACE_EVENTS_MAX = 100;
+/** Hub failureCategory is a closed enum; runtime failureKind is looser. Only the sure mapping is direct. */
+function failureCategoryFor(failureKind) {
+    if (failureKind === null)
+        return undefined;
+    if (failureKind === 'permission_denied')
+        return 'permission_error';
+    if (failureKind === 'timeout' || failureKind === 'non_zero_exit' || failureKind === 'invalid_output')
+        return 'tool_error';
+    return 'other';
+}
+function outcomeStatusFor(status) {
+    if (status === 'success')
+        return 'succeeded';
+    if (status === 'failed')
+        return 'failed';
+    return undefined;
+}
+/** Deterministic content hash over the draft body (hub contentHash column, dedup aid). */
+export function learningPacketContentHash(draft) {
+    return `sha256:${createHash('sha256').update(JSON.stringify(draft)).digest('hex')}`;
+}
+/** Map a core draft to the hub createLearningPacket body. Exported for tests and for the private adapter to reuse. */
+export function learningPacketWireBody(draft, nodeId) {
+    const truncated = draft.trajectory.length > HUB_TRACE_EVENTS_MAX;
+    const events = draft.trajectory.slice(0, HUB_TRACE_EVENTS_MAX);
+    const outcomeStatus = outcomeStatusFor(draft.evaluation.outcomeStatus);
+    const failureCategory = failureCategoryFor(draft.evaluation.failureCategory);
+    return {
+        schemaVersion: draft.schemaVersion,
+        status: 'draft',
+        sourceRepo: draft.source.repo,
+        sourceRun: draft.source.run,
+        sourceType: draft.source.type,
+        sourceId: draft.source.id,
+        // One packet per run: the run id IS the idempotency key, so a retried submit dedups hub-side (409).
+        idempotencyKey: `${draft.source.repo}:${draft.source.run}`,
+        contentHash: learningPacketContentHash(draft),
+        ...(nodeId ? { nodeId } : {}),
+        ...(outcomeStatus ? { outcomeStatus } : {}),
+        ...(failureCategory ? { failureCategory } : {}),
+        ...(draft.task.summary !== null ? { summary: draft.task.summary } : {}),
+        payload: {
+            task: draft.task,
+            context: draft.context,
+            artifacts: draft.artifacts,
+            evaluation: draft.evaluation,
+            governance: draft.governance,
+        },
+        metadata: {
+            ...(truncated ? { traceEventsTruncated: true, traceEventsTotal: draft.trajectory.length } : {}),
+            ...(draft.evaluation.failureCategory !== null ? { runtimeFailureKind: draft.evaluation.failureCategory } : {}),
+        },
+        redactionStatus: draft.governance.redactionStatus,
+        consentStatus: draft.governance.consentStatus,
+        retentionPolicy: draft.governance.retentionPolicy,
+        traceEvents: events.map((e) => ({
+            eventId: e.eventId,
+            schemaVersion: e.schemaVersion,
+            eventType: e.eventType,
+            occurredAt: e.occurredAt,
+            traceId: e.traceId,
+            ...(e.sessionId !== undefined ? { sessionId: e.sessionId } : {}),
+            ...(e.taskId !== undefined ? { taskId: e.taskId } : {}),
+            sequence: e.sequence,
+            payload: e.payload,
+            metadata: e.metadata,
+        })),
+    };
+}
+/**
+ * LearningPacketSink implementation against the public hub Learning Ops ingest API. Best-effort by
+ * contract: every failure returns { accepted: false, reason } (never throws) — the runtime treats packet
+ * delivery as observability, so a hub outage must never affect a task verdict. A 409 duplicate_source is
+ * reported as accepted (the packet is already there; the idempotency key did its job).
+ */
+export class HubLearningPacketSink {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async submit(draft) {
+        try {
+            const url = `${this.opts.baseUrl}/api/learning-packets`;
+            assertHubUrlSecure(url);
+            const signed = await this.opts.auth.authenticate({ method: 'POST', path: '/api/learning-packets' });
+            // The strict learning-packets schema rejects extra body fields, so a legacy body credential
+            // (bodyFields.node_secret) is promoted to Authorization: Bearer — the header requireAuth reads.
+            const headers = { 'content-type': 'application/json', ...(signed.headers ?? {}) };
+            const bodySecret = signed.bodyFields?.['node_secret'];
+            if (headers['authorization'] === undefined && bodySecret !== undefined)
+                headers['authorization'] = `Bearer ${String(bodySecret)}`;
+            const res = await this.opts.fetchFn(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(learningPacketWireBody(draft, this.opts.nodeId?.())),
+            });
+            if (res.status === 201) {
+                const body = await res.json().catch(() => null);
+                const packet = body && typeof body === 'object' ? body.packet : undefined;
+                return { accepted: true, ...(typeof packet?.id === 'string' ? { reason: packet.id } : {}) };
+            }
+            if (res.status === 409)
+                return { accepted: true, reason: 'duplicate_source' };
+            const text = await res.text().catch(() => '');
+            return { accepted: false, reason: `hub ${res.status}${text ? `: ${text.slice(0, 200)}` : ''}` };
+        }
+        catch (e) {
+            if (isHubUnreachableError(e))
+                return { accepted: false, reason: 'hub_unreachable' };
+            return { accepted: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+    }
+}
+/** Fan-out: always deliver to `primary` (local file record), then best-effort to `secondary` (hub upload).
+ *  The composite result reflects the PRIMARY sink — the local record is the durability guarantee. */
+export class TeeLearningPacketSink {
+    primary;
+    secondary;
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    async submit(draft) {
+        const primary = await this.primary.submit(draft);
+        try {
+            await this.secondary.submit(draft);
+        }
+        catch { /* secondary is best-effort by contract; sinks should not throw, but never let one break the record */ }
+        return primary;
+    }
+}

package/dist/wireMap.js

@@ -62,11 +62,17 @@ export function atpRetryClass(status) {
 export function publishRespToReceipt(status, body) {
     const payload = body['payload'] ?? body;
     const assetIds = payload['asset_ids'];
-    const assetId = payload['asset_id'] ?? body['asset_id'] ?? assetIds?.[0];
+    const targetAssetId = payload['target_asset_id']
+        ?? body['target_asset_id'];
+    const assetId = (status === 409 ? targetAssetId : undefined)
+        ?? payload['asset_id']
+        ?? body['asset_id']
+        ?? assetIds?.[0]
+        ?? targetAssetId;
     const bundleId = payload['bundle_id'];
     if (status >= 200 && status < 300) {
         const decision = String(payload['decision'] ?? payload['status'] ?? 'accepted');
-        const accepted = decision === 'accepted' || decision === 'approved' || decision === 'ok';
+        const accepted = decision === 'accept' || decision === 'accepted' || decision === 'approved' || decision === 'ok';
         return {
             receiptId: String(payload['receipt_id'] ?? bundleId ?? payload['id'] ?? assetId ?? 'unknown'),
             status: accepted ? 'accepted' : (decision === 'quarantine' ? 'quarantine' : 'rejected'),
@@ -85,6 +91,7 @@ export function publishRespToReceipt(status, body) {
         status: 'rejected',
         reason: String(payload['reason'] ?? reasonByStatus[status] ?? `hub ${status}`),
         ...(assetId ? { assetId } : {}),
+        ...(assetIds ? { assetIds } : {}),
         terminal: true,
     };
     if (status === 402) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-adapter-public",
-  "version": "2.0.0-beta.14",
+  "version": "2.0.0-beta.16",
   "private": false,
   "type": "module",
   "description": "公版 hub 适配器 (积分/治理)",
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@evomap/atp-sdk": "^0.1.0",
-    "@evomap/evolver-core": "2.0.0-beta.14",
+    "@evomap/evolver-core": "2.0.0-beta.16",
     "undici": "^6.27.0"
   },
   "optionalDependencies": {