@evomap/evolver-adapter-public 2.0.8 → 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

@@ -152,6 +152,12 @@ 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[]>;
+    /**
+     * 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=);

package/dist/hubCapability.js

@@ -286,41 +286,56 @@ export class PublicHubCapability {
         const body = await this.http.call('POST', '/a2a/fetch', gepEnvelope('fetch', searchQueryToFetchWire(query)));
         return assetsFromBody(body);
     }
-    async fetchAssetById(assetId, options) {
+    /**
+     * 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] }));
         const matches = [];
         for (const row of assetCandidatesFromBody(body)) {
             const asset = unwrapFetchDeliveryRow(row);
             if (!fetchDeliveryIdentityConsistent(row, asset))
-                return null;
-            if (id.startsWith('sha256:')) {
-                if (!assetMatchesId(asset, id)) {
-                    // The unverified escape hatch is intentionally narrower than the legacy verified aliases accepted by
-                    // assetMatchesId: a rewritten delivery must bind the requested content id through its canonical
-                    // asset_id field before a caller-owned quarantine path may opt in.
-                    if (stringField(asset, 'asset_id') !== id || !isExactUnverifiedContentDelivery(asset, id))
-                        return null;
+                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 null;
+                    return { status: 'rejected', reason: 'revoked' };
                 matches.push(asset);
                 continue;
             }
             if (fetchResultMatchesId(asset, id)) {
                 if (isRevokedFetchDelivery(row))
-                    return null;
+                    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.
-        if (!result || !/^sha256:[0-9a-f]{64}$/.test(id) || assetMatchesId(result, id))
-            return result;
-        return options?.allowUnverifiedExactIdentity === true ? result : null;
+        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=);
@@ -1148,26 +1163,8 @@ function unambiguousFetchResult(matches) {
     }
     return matches.find((asset) => stringField(asset, 'payload_backfill_reason') !== undefined) ?? matches[0];
 }
-function isExactUnverifiedContentDelivery(asset, requestedId) {
-    if (!/^sha256:[0-9a-f]{64}$/.test(requestedId))
-        return false;
-    if (stringField(asset, 'asset_id') !== requestedId)
-        return false;
-    const logicalId = stringField(asset, 'id');
-    if (!logicalId)
-        return false;
-    const wireAsset = stripHubDeliveryMetadataForIntegrity(asset);
-    try {
-        if (!wire.validateWireDeep(wireAsset).ok)
-            return false;
-        const deliveredContentId = wire.computeAssetId(wireAsset);
-        return typeof deliveredContentId === 'string'
-            && /^sha256:[0-9a-f]{64}$/.test(deliveredContentId)
-            && deliveredContentId !== requestedId;
-    }
-    catch {
-        return false;
-    }
+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/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.8",
+  "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.8",
+    "@evomap/evolver-core": "2.0.12",
     "undici": "^6.27.0"
   },
   "optionalDependencies": {