@evomap/evolver-adapter-public 2.0.2 → 2.0.12

package/dist/auth/credentialStore.js

@@ -596,7 +596,8 @@ export class CredentialStore {
                 throw new CredentialStoreError(`ancestor directory ${path} changed during ACL validation`);
             }
             for (let attempt = 0; attempt < 5; attempt += 1) {
-                const initialState = securityStateOf(bigFstat(fd));
+                const initialMetadata = bigFstat(fd);
+                const initialState = securityStateOf(initialMetadata);
                 let output;
                 try {
                     output = this.darwinAclReader(path);
@@ -613,12 +614,33 @@ export class CredentialStore {
                     !sameIdentity(after, identity) || !sameIdentity(openedAfter, identity)) {
                     throw new CredentialStoreError(`ancestor directory ${path} changed during ACL validation`);
                 }
-                const metadataStable = sameSecurityState(initialState, after) &&
-                    sameSecurityState(initialState, openedAfter);
-                if (metadataStable) {
+                if (sameSecurityState(initialState, after) && sameSecurityState(initialState, openedAfter)) {
                     this.securedAncestorStates.set(path, securityStateOf(openedAfter));
                     return;
                 }
+                if (sameDarwinAncestorMetadata(initialMetadata, after)
+                    && sameDarwinAncestorMetadata(initialMetadata, openedAfter)) {
+                    let confirmedOutput;
+                    try {
+                        confirmedOutput = this.darwinAclReader(path);
+                    }
+                    catch {
+                        throw new CredentialStoreError(`ancestor directory ${path} ACL could not be inspected`);
+                    }
+                    if (hasUnsafeDarwinAllowAcl(confirmedOutput, rejectAnyAllow)) {
+                        throw new CredentialStoreError(`ancestor directory ${path} grants access through an extended ACL`);
+                    }
+                    const confirmedPath = bigLstat(path);
+                    const confirmedOpened = bigFstat(fd);
+                    if (confirmedOutput === output
+                        && !confirmedPath.isSymbolicLink()
+                        && confirmedPath.isDirectory()
+                        && sameDarwinAncestorMetadata(initialMetadata, confirmedPath)
+                        && sameDarwinAncestorMetadata(initialMetadata, confirmedOpened)) {
+                        this.securedAncestorStates.set(path, securityStateOf(confirmedOpened));
+                        return;
+                    }
+                }
             }
             throw new CredentialStoreError(`ancestor directory ${path} changed during ACL validation`);
         }
@@ -1056,6 +1078,13 @@ function sameIdentity(left, right) {
 function sameSecurityState(left, right) {
     return sameIdentity(left, right) && left.ctimeNs === right.ctimeNs;
 }
+function sameDarwinAncestorMetadata(left, right) {
+    return sameIdentity(left, right)
+        && right.isDirectory()
+        && !right.isSymbolicLink()
+        && left.uid === right.uid
+        && left.mode === right.mode;
+}
 function samePathSecurityStates(left, right) {
     return left.length === right.length && left.every((state, index) => {
         const candidate = right[index];

package/dist/hubCapability.d.ts

@@ -58,6 +58,9 @@ export interface AccountAssetListResult {
     hasMore: boolean;
     nextCursor?: string;
 }
+export declare class MalformedAccountAssetPageError extends Error {
+    constructor();
+}
 /** 完整 GEP-A2A 信封(实测 dev: publish/fetch/validate 等协议消息端点必须全信封, 非仅 protocol+message_type). */
 export declare function gepEnvelope(messageType: string, payload: unknown, options?: {
     messageId?: string;
@@ -149,7 +152,13 @@ export declare class PublicHubCapability implements hub.HubCapability {
     private heartbeatMeta;
     publish(bundle: hub.AssetRecord[], options?: hub.PublishOptions): Promise<hub.PublishReceipt>;
     fetch(query: hub.HubQuery): Promise<hub.AssetRecord[]>;
-    fetchAssetById(assetId: string): Promise<hub.AssetRecord | null>;
+    /**
+     * Fetch one asset AND say why, when the answer is not an asset. `fetchAssetById` collapses every outcome to
+     * `null`, so a caller could not tell "the hub does not have this" from "the hub delivered something the
+     * client refuses" — and the CLI reported both as `not_found` on assets that demonstrably exist (#964).
+     */
+    fetchAssetDeliveryById(assetId: string, options?: hub.FetchAssetByIdOptions): Promise<hub.AssetDeliveryOutcome>;
+    fetchAssetById(assetId: string, options?: hub.FetchAssetByIdOptions): Promise<hub.AssetRecord | null>;
     /**
      * #69: search != fetch. Free-text is the hub's vector endpoint (GET /a2a/assets/semantic-search?q=);
      * signal/id queries use the Hub's free search-only phase on /a2a/fetch. /a2a/fetch does NOT do semantic,

package/dist/hubCapability.js

@@ -1,12 +1,12 @@
 import { createHash } from 'node:crypto';
-import { bootstrap, hub as hubNs, signals } from '@evomap/evolver-core';
+import { bootstrap, hub as hubNs, signals, wire } from '@evomap/evolver-core';
 import { AuthError, HubFetch, HubClientError, isHubUnreachableError } from './hubFetch.js';
 import { isNodeSecret, parseNodeSecretVersion } from './auth/legacyShim.js';
 import { inboundToAgentEvent, agentEventToOutbound, publishRespToReceipt, searchQueryToFetchWire, searchQueryToSearchOnlyWire, } from './wireMap.js';
 import { antiAbuseTelemetryMode, buildHeartbeatAntiAbuseTelemetry, } from './antiAbuseTelemetry.js';
 import { getWorkspaceKeychainMode } from './auth/workspaceKeychain.js';
 import { agentDirectoryFailure, parsePublicAgentPage, parsePublicAgentProfile, paginatePublicAgentPage, mergePublicAgentPages, publicAgentSearchQuery, publicTaskDiscoveryQuery, PUBLIC_TASK_DISCOVERY_MAX_CANDIDATES, unsupportedPublicAvailability, unsupportedPublicSort, withDirectoryTimeout, } from './agentDirectory.js';
-import { assetMatchesId } from './hubReuse.js';
+import { assetMatchesId, stripHubDeliveryMetadataForIntegrity } from './hubReuse.js';
 export const INBOUND_LIMIT = 100;
 export const OUTBOUND_MAX_BATCH = 50;
 export const OUTBOUND_MAX_BODY_BYTES = 4 * 1024 * 1024;
@@ -22,6 +22,12 @@ 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;
+export class MalformedAccountAssetPageError extends Error {
+    constructor() {
+        super('Hub account asset page is malformed');
+        this.name = 'MalformedAccountAssetPageError';
+    }
+}
 /** 完整 GEP-A2A 信封(实测 dev: publish/fetch/validate 等协议消息端点必须全信封, 非仅 protocol+message_type). */
 export function gepEnvelope(messageType, payload, options = {}) {
     return {
@@ -280,12 +286,56 @@ export class PublicHubCapability {
         const body = await this.http.call('POST', '/a2a/fetch', gepEnvelope('fetch', searchQueryToFetchWire(query)));
         return assetsFromBody(body);
     }
-    async fetchAssetById(assetId) {
+    /**
+     * Fetch one asset AND say why, when the answer is not an asset. `fetchAssetById` collapses every outcome to
+     * `null`, so a caller could not tell "the hub does not have this" from "the hub delivered something the
+     * client refuses" — and the CLI reported both as `not_found` on assets that demonstrably exist (#964).
+     */
+    async fetchAssetDeliveryById(assetId, options) {
         const id = assetId.trim();
         if (!id)
-            return null;
+            return { status: 'absent' };
         const body = await this.http.call('POST', '/a2a/fetch', gepEnvelope('fetch', { asset_ids: [id] }));
-        return assetsFromBody(body).find((asset) => fetchResultMatchesId(asset, id)) ?? null;
+        const matches = [];
+        for (const row of assetCandidatesFromBody(body)) {
+            const asset = unwrapFetchDeliveryRow(row);
+            if (!fetchDeliveryIdentityConsistent(row, asset))
+                return { status: 'rejected', reason: 'identity_mismatch' };
+            if (isContentAssetIdRequest(id)) {
+                // Identity is what this gate is for: the delivery must bind the REQUESTED content id through its own
+                // canonical `asset_id`. Whether the delivered body then hashes to that id, or satisfies the wire schema,
+                // is a trust question the caller resolves (quarantine + repair) — not grounds to drop the asset here.
+                if (!assetMatchesId(asset, id) && stringField(asset, 'asset_id') !== id) {
+                    return { status: 'rejected', reason: 'identity_mismatch' };
+                }
+                if (isRevokedFetchDelivery(row))
+                    return { status: 'rejected', reason: 'revoked' };
+                matches.push(asset);
+                continue;
+            }
+            if (fetchResultMatchesId(asset, id)) {
+                if (isRevokedFetchDelivery(row))
+                    return { status: 'rejected', reason: 'revoked' };
+                matches.push(asset);
+            }
+        }
+        if (matches.length === 0)
+            return { status: 'absent' };
+        const result = unambiguousFetchResult(matches);
+        if (!result)
+            return { status: 'rejected', reason: 'ambiguous' };
+        // Logical-id lookups retain their historical matching semantics. Only a canonical sha256 lookup can opt in
+        // to a content-hash drift, and every non-opted-in caller remains strict.
+        const verified = assetMatchesId(result, id);
+        if (verified || !isContentAssetIdRequest(id))
+            return { status: 'delivered', asset: result, verified: true };
+        return options?.allowUnverifiedExactIdentity === true
+            ? { status: 'delivered', asset: result, verified: false }
+            : { status: 'rejected', reason: 'unverified_not_allowed' };
+    }
+    async fetchAssetById(assetId, options) {
+        const outcome = await this.fetchAssetDeliveryById(assetId, options);
+        return outcome.status === 'delivered' ? outcome.asset : null;
     }
     /**
      * #69: search != fetch. Free-text is the hub's vector endpoint (GET /a2a/assets/semantic-search?q=);
@@ -368,16 +418,18 @@ export class PublicHubCapability {
             ...(opts.scope === 'published' && opts.status && opts.status !== 'all' ? { status: opts.status } : {}),
         };
         const body = await this.http.call('GET', path, undefined, query);
-        const payload = asRecord(body['payload']) ?? body;
+        const payload = Object.prototype.hasOwnProperty.call(body, 'payload')
+            ? asRecord(body['payload'])
+            : body;
+        if (!payload)
+            throw new MalformedAccountAssetPageError();
         const assets = accountAssetsFromPayload(payload);
         const count = numberField(payload, 'count');
-        const nextCursor = stringField(payload, 'next_cursor') ?? stringField(payload, 'nextCursor');
-        const hasMore = booleanField(payload, 'has_more') ?? booleanField(payload, 'hasMore') ?? Boolean(nextCursor);
+        const pagination = accountPaginationFromPayload(payload);
         return {
             assets,
             ...(count !== undefined ? { count } : {}),
-            hasMore,
-            ...(nextCursor ? { nextCursor } : {}),
+            ...pagination,
         };
     }
     /**
@@ -850,7 +902,7 @@ function dryRunRecipeReceipt(action, recipeId, extra = {}) {
         },
     };
 }
-function assetsFromBody(body) {
+function assetCandidatesFromBody(body) {
     const payload = asRecord(body['payload']);
     const candidates = [
         body['asset'],
@@ -861,15 +913,25 @@ function assetsFromBody(body) {
         ...(Array.isArray(payload?.['results']) ? payload['results'] : []),
     ];
     return candidates
-        .filter((candidate) => Boolean(candidate && typeof candidate === 'object' && !Array.isArray(candidate)))
-        .map(unwrapFetchDeliveryRow);
+        .filter((candidate) => Boolean(candidate && typeof candidate === 'object' && !Array.isArray(candidate)));
+}
+function assetsFromBody(body) {
+    return assetCandidatesFromBody(body).map(unwrapFetchDeliveryRow);
 }
 // Delivery-row metadata carried over onto the unwrapped GEP record. Ranking fields are consumed by
 // hubReuse and stripped before canonical storage. `payload_backfill_reason` must also survive this
 // boundary so integrity consumers can report that the Hub synthesized the payload (#570). Do not
 // carry `confidence`: it is transport metadata on Gene rows but canonical content on Capsules, so
 // overloading it can either poison a Gene hash or overwrite Capsule content (#565).
-const FETCH_ROW_CARRYOVER_KEYS = ['gdi_score', 'success_rate', 'reuse_count', 'source_node_id', 'payload_backfill_reason'];
+const FETCH_ROW_CARRYOVER_KEYS = [
+    'gdi_score',
+    'success_rate',
+    'reuse_count',
+    'source_node_id',
+    'payload_backfill_reason',
+    'status',
+    'trust_state',
+];
 /**
  * The live hub's /a2a/fetch results are DELIVERY ROWS, not raw GEP records (#565, observed on
  * evomap.ai 2026-07-22): the record itself nests under `payload`, while the row's own keys are
@@ -893,20 +955,89 @@ function unwrapFetchDeliveryRow(row) {
     }
     return { ...inner, ...carryover };
 }
+function fetchDeliveryIdentityConsistent(row, asset) {
+    const outer = row;
+    if (typeof outer['type'] === 'string') {
+        const transportType = stringField(outer, 'asset_type');
+        if (transportType !== undefined && transportType !== outer['type'])
+            return false;
+        const transportLogicalId = stringField(outer, 'local_id');
+        if (transportLogicalId !== undefined && transportLogicalId !== stringField(outer, 'id'))
+            return false;
+        return true;
+    }
+    const inner = asRecord(outer['payload']);
+    if (!inner)
+        return false;
+    const outerAssetId = stringField(outer, 'asset_id');
+    const innerAssetId = stringField(inner, 'asset_id');
+    if (!outerAssetId || !innerAssetId || outerAssetId !== innerAssetId)
+        return false;
+    const outerType = stringField(outer, 'asset_type');
+    const innerType = stringField(inner, 'type');
+    if (outerType !== undefined && outerType !== innerType)
+        return false;
+    const innerLogicalId = stringField(inner, 'id');
+    for (const key of ['id', 'local_id']) {
+        const outerLogicalId = stringField(outer, key);
+        if (outerLogicalId !== undefined && outerLogicalId !== innerLogicalId)
+            return false;
+    }
+    for (const key of ['status', 'trust_state']) {
+        const outerMarker = stringField(outer, key);
+        const innerMarker = stringField(inner, key);
+        const outerRevoked = isRevokedMarker(outerMarker);
+        const innerRevoked = isRevokedMarker(innerMarker);
+        if (outerMarker !== undefined && innerMarker !== undefined && outerRevoked !== innerRevoked)
+            return false;
+    }
+    return asset === row || stringField(asset, 'asset_id') === innerAssetId;
+}
+function isRevokedFetchDelivery(row) {
+    const record = row;
+    const nested = asRecord(record['payload']);
+    return [record, ...(nested ? [nested] : [])].some((value) => (isRevokedMarker(value['status'])
+        || isRevokedMarker(value['trust_state'])));
+}
+function isRevokedMarker(raw) {
+    return typeof raw === 'string' && raw.trim().toLowerCase() === 'revoked';
+}
 function accountAssetsFromPayload(payload) {
-    const candidates = [
-        payload['assets'],
-        payload['results'],
-        payload['items'],
-    ];
-    for (const candidate of candidates) {
-        if (!Array.isArray(candidate))
-            continue;
-        return candidate
-            .filter((asset) => Boolean(asset && typeof asset === 'object' && !Array.isArray(asset)))
-            .map(unwrapFetchDeliveryRow);
+    const keys = ['assets', 'results', 'items']
+        .filter((key) => Object.prototype.hasOwnProperty.call(payload, key));
+    if (keys.length !== 1)
+        throw new MalformedAccountAssetPageError();
+    const candidate = payload[keys[0]];
+    if (!Array.isArray(candidate) || candidate.some((asset) => !asset || typeof asset !== 'object' || Array.isArray(asset))) {
+        throw new MalformedAccountAssetPageError();
     }
-    return [];
+    return candidate.map((row) => {
+        const asset = unwrapFetchDeliveryRow(row);
+        return fetchDeliveryIdentityConsistent(row, asset) ? asset : row;
+    });
+}
+function accountPaginationFromPayload(payload) {
+    const snakeHasMore = payload['has_more'];
+    const camelHasMore = payload['hasMore'];
+    if ((snakeHasMore !== undefined && typeof snakeHasMore !== 'boolean')
+        || (camelHasMore !== undefined && typeof camelHasMore !== 'boolean')
+        || (snakeHasMore === undefined && camelHasMore === undefined)
+        || (typeof snakeHasMore === 'boolean' && typeof camelHasMore === 'boolean' && snakeHasMore !== camelHasMore)) {
+        throw new MalformedAccountAssetPageError();
+    }
+    const hasMore = typeof snakeHasMore === 'boolean' ? snakeHasMore : camelHasMore;
+    const rawCursors = [payload['next_cursor'], payload['nextCursor']]
+        .filter((value) => value !== undefined && value !== null);
+    if (rawCursors.some((value) => typeof value !== 'string' || !value.trim())) {
+        throw new MalformedAccountAssetPageError();
+    }
+    if (rawCursors.length === 2 && rawCursors[0] !== rawCursors[1]) {
+        throw new MalformedAccountAssetPageError();
+    }
+    const nextCursor = rawCursors[0];
+    if (hasMore !== Boolean(nextCursor))
+        throw new MalformedAccountAssetPageError();
+    return { hasMore, ...(nextCursor ? { nextCursor } : {}) };
 }
 function learningAssetsFromPayload(payload) {
     const candidates = [
@@ -1010,7 +1141,30 @@ function failureReason(error) {
 function fetchResultMatchesId(asset, requestedId) {
     if (assetMatchesId(asset, requestedId))
         return true;
-    return !requestedId.startsWith('sha256:') && Boolean(asset && stringField(asset, 'id') === requestedId);
+    if (!asset)
+        return false;
+    if (!requestedId.startsWith('sha256:'))
+        return stringField(asset, 'id') === requestedId;
+    return false;
+}
+function unambiguousFetchResult(matches) {
+    if (matches.length === 0)
+        return null;
+    let canonical;
+    try {
+        canonical = wire.canonicalize(stripHubDeliveryMetadataForIntegrity(matches[0]));
+        for (const asset of matches.slice(1)) {
+            if (wire.canonicalize(stripHubDeliveryMetadataForIntegrity(asset)) !== canonical)
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return matches.find((asset) => stringField(asset, 'payload_backfill_reason') !== undefined) ?? matches[0];
+}
+function isContentAssetIdRequest(requestedId) {
+    return /^sha256:[0-9a-f]{64}$/.test(requestedId);
 }
 function stringField(value, key) {
     return typeof value[key] === 'string' && value[key].length > 0 ? value[key] : undefined;

package/dist/hubReuse.d.ts

@@ -50,6 +50,7 @@ export declare class ReuseCache {
     setPayload(assetId: string, payload: hub.AssetRecord): void;
     clear(): void;
 }
+export declare function stripHubDeliveryMetadataForIntegrity(rec: hub.AssetRecord): hub.AssetRecord;
 /**
  * Map a hub search row (AssetRecord with arbitrary quality fields) → the core's price-free HubMetadata.
  * Accepts both camelCase and the hub's snake_case (gdi_score / success_rate / reuse_count / ...). Drops any

package/dist/hubReuse.js

@@ -36,6 +36,7 @@ const GENE_WIRE_KEYS = new Set([
 ]);
 const HUB_DELIVERY_METADATA_KEYS = new Set([
     'status',
+    'trust_state',
     'success_streak',
     'reputation_score',
     'gdi_score',
@@ -55,8 +56,15 @@ const HUB_DELIVERY_METADATA_KEYS = new Set([
     'semanticSimilarity',
     '_search_score',
     'search_score',
+    '_match_score',
+    'match_score',
+    '_retrieval_rank',
+    'retrieval_rank',
     'payload_backfill_reason',
+    'original_asset_id',
     'asset_type',
+    'local_id',
+    'source',
     'bundle_id',
     'callable',
     'payload_ready',
@@ -246,10 +254,15 @@ function stripHubPayloadMetadata(rec) {
     }
     return out;
 }
-function stripHubDeliveryMetadataForIntegrity(rec) {
+// Shared content projection for by-id verification and sync quarantine classification.
+export function stripHubDeliveryMetadataForIntegrity(rec) {
     const out = { ...rec };
-    for (const key of HUB_DELIVERY_METADATA_KEYS)
+    for (const key of HUB_DELIVERY_METADATA_KEYS) {
+        // Hub ranking streak is metadata for Genes, while Capsule.success_streak is canonical content.
+        if (key === 'success_streak' && out['type'] === 'Capsule')
+            continue;
         delete out[key];
+    }
     // Hub ranking confidence is metadata for Genes, while Capsule.confidence is canonical content.
     if (out['type'] === 'Gene')
         delete out['confidence'];

package/dist/learningPacketSink.d.ts

@@ -9,7 +9,15 @@ export interface HubLearningPacketSinkOptions {
     /** 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). */
+/**
+ * Deterministic content hash over the draft body (hub contentHash column, dedup aid).
+ *
+ * Bare 64-hex, NOT `sha256:`-prefixed: the hub column is VarChar(64), so a prefixed
+ * digest is 71 chars and every upload failed with a Prisma "value too long" 500. The
+ * hub schema now rejects over-64 at validation, which would make it a 400 instead —
+ * either way the algorithm is fixed at sha256 by this contract, so the prefix carried
+ * no information.
+ */
 export declare function learningPacketContentHash(draft: trace.LearningPacketDraft): string;
 /**
  * Auth headers for the strict learning-packets routes (requireAuth reads Authorization only).

package/dist/learningPacketSink.js

@@ -19,16 +19,47 @@ function failureCategoryFor(failureKind) {
         return 'tool_error';
     return 'other';
 }
-function outcomeStatusFor(status) {
-    if (status === 'success')
-        return 'succeeded';
+/**
+ * Map the runtime's outcome onto the hub OUTCOME_STATUSES enum, tiered by whether an
+ * external verifier actually adjudicated the run.
+ *
+ * A verified run gets a definite verdict (`succeeded` / `failed`). An unverified one
+ * gets `partially_succeeded` -- deliberately NOT `succeeded`, and no longer omitted:
+ *
+ * - Omitting it (the previous behaviour) threw the run away. The packet reached the
+ *   hub with no outcome at all, which is indistinguishable from a run nobody looked
+ *   at, so a consumer could not tell "we don't know" from "not recorded".
+ * - Calling it `succeeded` would be worse: the runtime only knows the turn loop
+ *   ended without crashing, which is not evidence the task was done correctly.
+ *   Training on that teaches format imitation.
+ *
+ * `partially_succeeded` says exactly what is true -- it ran to completion and nobody
+ * checked the result -- and pairs with `verifier` being absent, so a consumer filters
+ * on the verifier rather than having to infer trust from the status. Darwin's training
+ * path takes only rows with a real verifier; see docs/rsi-stage1-plan.md.
+ * @param status Runtime-side outcome.
+ * @param verified True when an external verifier ran (evaluation.placeholder === false).
+ * @returns A hub OUTCOME_STATUSES value.
+ */
+function outcomeStatusFor(status, verified) {
     if (status === 'failed')
         return 'failed';
-    return undefined;
+    if (status === 'success' && verified)
+        return 'succeeded';
+    // Ran to completion, unadjudicated -- or the runtime itself is unsure.
+    return 'partially_succeeded';
 }
-/** Deterministic content hash over the draft body (hub contentHash column, dedup aid). */
+/**
+ * Deterministic content hash over the draft body (hub contentHash column, dedup aid).
+ *
+ * Bare 64-hex, NOT `sha256:`-prefixed: the hub column is VarChar(64), so a prefixed
+ * digest is 71 chars and every upload failed with a Prisma "value too long" 500. The
+ * hub schema now rejects over-64 at validation, which would make it a 400 instead —
+ * either way the algorithm is fixed at sha256 by this contract, so the prefix carried
+ * no information.
+ */
 export function learningPacketContentHash(draft) {
-    return `sha256:${createHash('sha256').update(JSON.stringify(draft)).digest('hex')}`;
+    return createHash('sha256').update(JSON.stringify(draft)).digest('hex');
 }
 /**
  * Auth headers for the strict learning-packets routes (requireAuth reads Authorization only).
@@ -47,7 +78,7 @@ export async function learningOpsAuthHeaders(auth, method, path) {
 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 outcomeStatus = outcomeStatusFor(draft.evaluation.outcomeStatus, draft.evaluation.placeholder === false);
     const failureCategory = failureCategoryFor(draft.evaluation.failureCategory);
     return {
         schemaVersion: draft.schemaVersion,
@@ -60,7 +91,7 @@ export function learningPacketWireBody(draft, nodeId) {
         idempotencyKey: `${draft.source.repo}:${draft.source.run}`,
         contentHash: learningPacketContentHash(draft),
         ...(nodeId ? { nodeId } : {}),
-        ...(outcomeStatus ? { outcomeStatus } : {}),
+        outcomeStatus,
         // evaluation fill-in (slice 6): a non-placeholder evaluation carries the runtime's external verifier
         // ('automated_test' is in the hub VERIFIERS enum); passed/score details ride inside payload.evaluation.
         ...(draft.evaluation.verifier !== null ? { verifier: draft.evaluation.verifier } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-adapter-public",
-  "version": "2.0.2",
+  "version": "2.0.12",
   "private": false,
   "type": "module",
   "engines": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@evomap/atp-sdk": "^0.1.0",
-    "@evomap/evolver-core": "2.0.2",
+    "@evomap/evolver-core": "2.0.12",
     "undici": "^6.27.0"
   },
   "optionalDependencies": {