@evomap/evolver-adapter-public 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/agentDirectory.d.ts

@@ -0,0 +1,12 @@
+import { type hub } from '@evomap/evolver-core';
+export declare const PUBLIC_TASK_DISCOVERY_MAX_CANDIDATES: number;
+export declare function publicAgentSearchQuery(request: hub.AgentSearchRequest): Record<string, string | number | undefined>;
+export declare function unsupportedPublicAvailability(availability: hub.AgentAvailability | undefined): hub.AgentDirectoryResult<never> | undefined;
+export declare function unsupportedPublicSort(sort: hub.AgentDirectorySort | undefined): hub.AgentDirectoryResult<never> | undefined;
+export declare function publicTaskDiscoveryQuery(request: hub.AgentTaskDiscoveryRequest): Record<string, string | number | undefined>;
+export declare function parsePublicAgentPage(body: unknown): hub.AgentDirectoryResult<hub.AgentDirectoryPage>;
+export declare function paginatePublicAgentPage(page: hub.AgentDirectoryResult<hub.AgentDirectoryPage>, request: hub.AgentSearchRequest, maxOffset?: number): hub.AgentDirectoryResult<hub.AgentDirectoryPage>;
+export declare function mergePublicAgentPages(pages: readonly hub.AgentDirectoryResult<hub.AgentDirectoryPage>[]): hub.AgentDirectoryResult<hub.AgentDirectoryPage>;
+export declare function parsePublicAgentProfile(body: unknown): hub.AgentDirectoryResult<hub.AgentProfile | null>;
+export declare function agentDirectoryFailure(error: unknown): hub.AgentDirectoryResult<never>;
+export declare function withDirectoryTimeout<T>(operation: Promise<T>, timeoutMs: number): Promise<T>;

package/dist/agentDirectory.js

@@ -0,0 +1,293 @@
+import { hub as hubNs } from '@evomap/evolver-core';
+import { AuthError, HubClientError, HubUnreachableError } from './hubFetch.js';
+const MAX_TEXT_LENGTH = 500;
+const MAX_CAPABILITY_COUNT = 50;
+export const PUBLIC_TASK_DISCOVERY_MAX_CANDIDATES = hubNs.AGENT_DIRECTORY_MAX_LIMIT * 2;
+export function publicAgentSearchQuery(request) {
+    const normalized = hubNs.normalizeAgentSearchRequest(request);
+    return {
+        ...(normalized.query ? { q: normalized.query } : {}),
+        ...(normalized.signals && normalized.signals.length > 0 ? { signals: normalized.signals.join(',') } : {}),
+        limit: hubNs.AGENT_DIRECTORY_MAX_LIMIT,
+        online_only: normalized.availability === 'offline' ? 'false' : 'true',
+    };
+}
+export function unsupportedPublicAvailability(availability) {
+    if (availability === 'busy' || availability === 'offline' || availability === 'unknown') {
+        return hubNs.capabilityUnavailable(`public_hub_availability_${availability}_not_supported`);
+    }
+    return undefined;
+}
+export function unsupportedPublicSort(sort) {
+    if (sort === 'recent')
+        return hubNs.capabilityUnavailable('public_hub_sort_recent_not_supported');
+    return undefined;
+}
+export function publicTaskDiscoveryQuery(request) {
+    return publicAgentSearchQuery(hubNs.normalizeAgentTaskDiscoveryRequest(request));
+}
+export function parsePublicAgentPage(body) {
+    const record = asRecord(body);
+    const payload = asRecord(record?.['payload']) ?? record;
+    const rawItems = Array.isArray(payload?.['results'])
+        ? payload['results']
+        : Array.isArray(payload?.['agents'])
+            ? payload['agents']
+            : Array.isArray(body)
+                ? body
+                : undefined;
+    if (!rawItems)
+        return invalidResponse('agent_directory_results_missing');
+    const items = [];
+    for (const raw of rawItems) {
+        const parsed = parseAgentEntry(raw);
+        if (!parsed)
+            return invalidResponse('agent_directory_entry_invalid');
+        items.push(parsed);
+    }
+    const nextCursor = optionalString(payload?.['next_cursor'] ?? payload?.['nextCursor'], 256);
+    const hasMoreValue = payload?.['has_more'] ?? payload?.['hasMore'];
+    if (hasMoreValue !== undefined && typeof hasMoreValue !== 'boolean')
+        return invalidResponse('agent_directory_has_more_invalid');
+    return { ok: true, value: { items, ...(nextCursor ? { nextCursor } : {}), hasMore: typeof hasMoreValue === 'boolean' ? hasMoreValue : Boolean(nextCursor) } };
+}
+export function paginatePublicAgentPage(page, request, maxOffset = hubNs.AGENT_DIRECTORY_MAX_LIMIT) {
+    if (!page.ok)
+        return page;
+    const normalized = hubNs.normalizeAgentSearchRequest(request);
+    const offset = cursorOffset(normalized.cursor, maxOffset);
+    const filtered = normalized.availability
+        ? page.value.items.filter((item) => item.availability === normalized.availability)
+        : page.value.items;
+    const items = [...filtered].sort(agentComparator(normalized.sort, normalized.order));
+    const slice = items.slice(offset, offset + normalized.limit);
+    const nextOffset = offset + slice.length;
+    return {
+        ok: true,
+        value: {
+            items: slice,
+            ...(nextOffset < items.length ? { nextCursor: `offset:${nextOffset}` } : {}),
+            hasMore: nextOffset < items.length,
+        },
+    };
+}
+export function mergePublicAgentPages(pages) {
+    const failed = pages.find((page) => !page.ok);
+    if (failed && !failed.ok)
+        return failed;
+    const items = new Map();
+    for (const page of pages) {
+        if (!page.ok)
+            continue;
+        for (const item of page.value.items) {
+            const previous = items.get(item.agentId);
+            if (!previous || (item.score ?? -1) > (previous.score ?? -1))
+                items.set(item.agentId, item);
+        }
+    }
+    return { ok: true, value: { items: [...items.values()], hasMore: false } };
+}
+export function parsePublicAgentProfile(body) {
+    if (body === null)
+        return { ok: true, value: null };
+    const record = asRecord(body);
+    const payload = asRecord(record?.['payload']) ?? record;
+    const profile = asRecord(payload?.['profile']) ?? payload;
+    if (!profile)
+        return invalidResponse('agent_profile_invalid');
+    const entry = parseAgentEntry(profile);
+    if (!entry)
+        return invalidResponse('agent_profile_invalid');
+    const taskStatsCompletedCount = completedTaskCountFromTaskStats(profile['task_stats']);
+    if (taskStatsCompletedCount === null)
+        return invalidResponse('agent_profile_invalid');
+    const { score: _score, ...safeProfile } = entry;
+    return {
+        ok: true,
+        value: {
+            ...safeProfile,
+            ...(safeProfile.completedTaskCount === undefined && taskStatsCompletedCount !== undefined
+                ? { completedTaskCount: taskStatsCompletedCount }
+                : {}),
+        },
+    };
+}
+export function agentDirectoryFailure(error) {
+    if (error instanceof hubNs.AgentDirectoryInputError)
+        return { ok: false, error: { code: 'invalid_request', retryable: false, message: error.message } };
+    if (error instanceof DirectoryTimeoutError)
+        return { ok: false, error: { code: 'timeout', retryable: true, message: 'agent_directory_timeout' } };
+    if (error instanceof AuthError)
+        return { ok: false, error: { code: 'permission_denied', retryable: false, message: 'agent_directory_permission_denied' } };
+    if (error instanceof HubClientError && (error.status === 404 || error.status === 405 || error.status === 501))
+        return hubNs.capabilityUnavailable();
+    if (error instanceof HubUnreachableError || isNetworkError(error))
+        return { ok: false, error: { code: 'hub_unavailable', retryable: true, message: 'agent_directory_hub_unavailable' } };
+    if (error instanceof HubClientError)
+        return { ok: false, error: { code: 'invalid_request', retryable: false, message: `agent_directory_hub_${error.status}` } };
+    return { ok: false, error: { code: 'hub_unavailable', retryable: true, message: 'agent_directory_request_failed' } };
+}
+export async function withDirectoryTimeout(operation, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new DirectoryTimeoutError()), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+class DirectoryTimeoutError extends Error {
+}
+function parseAgentEntry(value) {
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    const agentId = optionalString(record['agent_id'] ?? record['agentId'] ?? record['node_id'] ?? record['nodeId'], 128);
+    if (!agentId)
+        return undefined;
+    const capabilitiesValue = record['capabilities'];
+    const capabilities = stringList(capabilitiesValue === undefined || capabilitiesValue === null ? record['signals'] : capabilitiesValue);
+    const domains = stringArray(record['domains']);
+    if (capabilities === null || domains === null)
+        return undefined;
+    const availability = availabilityValue(record['availability'], record['online']);
+    const score = optionalBoundedNumber(record['score'], 0, 1);
+    const reputation = optionalBoundedNumber(record['reputation'], 0, 1_000_000);
+    const completedTaskCount = optionalInteger(record['completed_tasks'] ?? record['completedTaskCount'], 0);
+    const lastSeenAt = optionalTimestamp(record['last_seen_at'] ?? record['lastSeenAt']);
+    if (availability === null || score === null || reputation === null || completedTaskCount === null || lastSeenAt === null)
+        return undefined;
+    return {
+        agentId,
+        ...(optionalString(record['display_name'] ?? record['displayName'] ?? record['name'] ?? record['alias'], 120) ? { displayName: optionalString(record['display_name'] ?? record['displayName'] ?? record['name'] ?? record['alias'], 120) } : {}),
+        ...(optionalString(record['summary'] ?? record['description'], MAX_TEXT_LENGTH) ? { summary: optionalString(record['summary'] ?? record['description'], MAX_TEXT_LENGTH) } : {}),
+        ...(capabilities !== undefined ? { capabilities } : {}),
+        ...(domains !== undefined ? { domains } : {}),
+        ...(score !== undefined ? { score } : {}),
+        ...(reputation !== undefined ? { reputation } : {}),
+        ...(completedTaskCount !== undefined ? { completedTaskCount } : {}),
+        ...(availability ? { availability } : {}),
+        ...(lastSeenAt !== undefined ? { lastSeenAt } : {}),
+    };
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function optionalString(value, maxLength) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    return text && text.length <= maxLength ? text : undefined;
+}
+function stringArray(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value) || value.length > MAX_CAPABILITY_COUNT)
+        return null;
+    const output = [];
+    for (const item of value) {
+        const text = optionalString(item, 64);
+        if (!text)
+            return null;
+        if (!output.includes(text))
+            output.push(text);
+    }
+    return output;
+}
+function stringList(value) {
+    if (typeof value === 'string')
+        return stringArray(value.split(',').map((item) => item.trim()).filter(Boolean));
+    return stringArray(value);
+}
+function completedTaskCountFromTaskStats(value) {
+    if (value === undefined)
+        return undefined;
+    const taskStats = asRecord(value);
+    if (!taskStats)
+        return null;
+    if (!hasOwn(taskStats, 'completed'))
+        return undefined;
+    const completed = taskStats['completed'];
+    if (!Number.isInteger(completed) || Number(completed) < 0)
+        return null;
+    return Number(completed);
+}
+function availabilityValue(value, online) {
+    if (value === 'online' || value === 'busy' || value === 'offline' || value === 'unknown')
+        return value;
+    if (value !== undefined)
+        return null;
+    if (online === true)
+        return 'online';
+    if (online === false)
+        return 'offline';
+    if (online !== undefined)
+        return null;
+    return undefined;
+}
+function optionalBoundedNumber(value, min, max) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < min || value > max)
+        return null;
+    return value;
+}
+function optionalInteger(value, min) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Number.isInteger(value) || Number(value) < min)
+        return null;
+    return Number(value);
+}
+function optionalTimestamp(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+        return value;
+    if (typeof value === 'string' && value.length <= 64) {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function invalidResponse(message) {
+    return { ok: false, error: { code: 'invalid_response', retryable: false, message } };
+}
+function cursorOffset(cursor, maxOffset) {
+    if (!cursor)
+        return 0;
+    const match = /^offset:(\d+)$/.exec(cursor);
+    const offset = match ? Number(match[1]) : NaN;
+    if (!Number.isInteger(offset) || offset < 0 || offset > maxOffset) {
+        throw new hubNs.AgentDirectoryInputError('cursor_invalid');
+    }
+    return offset;
+}
+function agentComparator(sort, order) {
+    const direction = order === 'asc' ? 1 : -1;
+    return (left, right) => direction * (sortValue(left, sort) - sortValue(right, sort)) || left.agentId.localeCompare(right.agentId);
+}
+function sortValue(entry, sort) {
+    if (sort === 'reputation')
+        return entry.reputation ?? -1;
+    if (sort === 'recent')
+        return entry.lastSeenAt ?? -1;
+    if (sort === 'availability')
+        return entry.availability === 'online' ? 3 : entry.availability === 'busy' ? 2 : entry.availability === 'unknown' ? 1 : 0;
+    return entry.score ?? -1;
+}
+function isNetworkError(error) {
+    const record = asRecord(error);
+    return record?.['name'] === 'AbortError' || record?.['name'] === 'TimeoutError' || record?.['code'] === 'HUB_UNREACHABLE';
+}

package/dist/antiAbuseTelemetry.d.ts

@@ -17,6 +17,7 @@ export interface AntiAbuseTelemetryOptions {
     evolverVersion?: string;
     taskMeta?: Record<string, unknown>;
     workspaceId?: string;
+    workspaceIdResolver?: () => string | null;
 }
 export interface IntegrityHashes {
     package_json_hash: string | null;

package/dist/antiAbuseTelemetry.js

@@ -103,10 +103,10 @@ export function buildHeartbeatAntiAbuseTelemetry(opts = {}) {
     const saltId = opts.saltId ?? env['EVOLVER_ANTI_ABUSE_SALT_ID'] ?? (salt ? 'env' : null);
     const pseudonymStatus = salt ? 'salt_configured' : 'salt_missing';
     const devicePseudonym = hmacPseudonym(fp.device, { salt, purpose: 'device' });
-    const workspacePseudonym = hmacPseudonym(opts.workspaceId ?? process.cwd(), { salt, purpose: 'workspace' });
+    const workspacePseudonym = salt ? hmacPseudonym(resolveTelemetryWorkspaceId(opts), { salt, purpose: 'workspace' }) : null;
     const unavailableFields = [
         ...(devicePseudonym ? [] : [unavailable('device_pseudonym', 'anti_abuse_salt_missing', 'signed_policy_or_env')]),
-        ...(workspacePseudonym ? [] : [unavailable('workspace_pseudonym', 'anti_abuse_salt_missing', 'signed_policy_or_env')]),
+        ...(workspacePseudonym ? [] : [unavailable('workspace_pseudonym', salt ? 'workspace_id_unavailable' : 'anti_abuse_salt_missing', salt ? 'workspace_keychain_or_filesystem' : 'signed_policy_or_env')]),
         unavailable('client_ip', 'server_observed_required', 'hub_edge'),
         unavailable('asn', 'server_observed_required', 'hub_edge'),
         unavailable('proxy_vpn_tor_datacenter_class', 'server_observed_required', 'hub_edge'),
@@ -213,6 +213,13 @@ function nowIso(now) {
         return now;
     return new Date().toISOString();
 }
+function resolveTelemetryWorkspaceId(opts) {
+    if (opts.workspaceId)
+        return opts.workspaceId;
+    if (opts.workspaceIdResolver)
+        return opts.workspaceIdResolver();
+    return process.cwd();
+}
 function boolFromEnv(value) {
     const v = String(value ?? '').trim().toLowerCase();
     return v === '1' || v === 'true' || v === 'yes' || v === 'on';

package/dist/auth/workspaceKeychain.d.ts

@@ -0,0 +1,37 @@
+export declare const WORKSPACE_KEYCHAIN_SERVICE = "evomap.evolver.workspace-id";
+export type WorkspaceKeychainMode = 'auto' | 'force' | 'off';
+export interface WorkspaceKeychainEntry {
+    getPassword(): string | null | undefined;
+    setPassword(password: string): void;
+}
+export interface WorkspaceKeychainAddon {
+    Entry: new (service: string, account: string) => WorkspaceKeychainEntry;
+}
+export interface WorkspaceKeychainReadResult {
+    available: boolean;
+    id: string | null;
+}
+export interface WorkspaceKeychainOps {
+    loadAddon(): WorkspaceKeychainAddon | null;
+    readFromKeychain(account: string): WorkspaceKeychainReadResult;
+    writeToKeychain(account: string, id: string): boolean;
+    getMode(env?: Record<string, string | undefined>): WorkspaceKeychainMode;
+}
+export interface WorkspaceIdentityOptions {
+    env?: Record<string, string | undefined>;
+    cwd?: string;
+    workspaceRoot?: string;
+    keychain?: WorkspaceKeychainOps;
+}
+export declare function resetWorkspaceKeychainAddonCacheForTests(): void;
+export declare function getWorkspaceKeychainMode(env?: Record<string, string | undefined>): WorkspaceKeychainMode;
+export declare function loadWorkspaceKeychainAddon(): WorkspaceKeychainAddon | null;
+export declare function isWorkspaceKeychainNoEntryError(err: unknown): boolean;
+export declare function readFromWorkspaceKeychain(account: string, addon?: WorkspaceKeychainAddon | null): WorkspaceKeychainReadResult;
+export declare function writeToWorkspaceKeychain(account: string, id: string, addon?: WorkspaceKeychainAddon | null): boolean;
+export declare const defaultWorkspaceKeychain: WorkspaceKeychainOps;
+export declare function workspaceIdPath(workspaceRoot: string): string;
+export declare function resolveWorkspaceRootForIdentity(opts?: Pick<WorkspaceIdentityOptions, 'env' | 'cwd'>): string;
+export declare function resolveWorkspaceId(opts?: WorkspaceIdentityOptions): string | null;
+export declare function readWorkspaceIdFromFs(file: string): string | null;
+export declare function writeWorkspaceIdToFs(file: string, id?: string): string | null;

package/dist/auth/workspaceKeychain.js

@@ -0,0 +1,251 @@
+import { randomBytes } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { constants, chmodSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, writeSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+export const WORKSPACE_KEYCHAIN_SERVICE = 'evomap.evolver.workspace-id';
+const WORKSPACE_ID_RE = /^[a-f0-9]{32,}$/i;
+const require = createRequire(import.meta.url);
+let cachedAddon;
+export function resetWorkspaceKeychainAddonCacheForTests() {
+    cachedAddon = undefined;
+}
+export function getWorkspaceKeychainMode(env = process.env) {
+    const raw = String(env['EVOLVER_WORKSPACE_KEYCHAIN'] ?? 'auto').trim().toLowerCase();
+    return raw === 'force' || raw === 'off' || raw === 'auto' ? raw : 'auto';
+}
+export function loadWorkspaceKeychainAddon() {
+    if (cachedAddon !== undefined)
+        return cachedAddon;
+    try {
+        const mod = require('@napi-rs/keyring');
+        cachedAddon = typeof mod.Entry === 'function' ? mod : null;
+    }
+    catch {
+        cachedAddon = null;
+    }
+    return cachedAddon;
+}
+const NO_ENTRY_PATTERNS = [
+    /no\s+matching\s+entry/i,
+    /could\s+not\s+be\s+found/i,
+    /element\s+not\s+found/i,
+    /\bnoentry\b/i,
+    /\bno\s*entry\b/i,
+    /not\s+found\s+in\s+(?:secure|keychain)/i,
+];
+export function isWorkspaceKeychainNoEntryError(err) {
+    const message = err instanceof Error ? err.message : '';
+    return NO_ENTRY_PATTERNS.some((pattern) => pattern.test(message));
+}
+export function readFromWorkspaceKeychain(account, addon = loadWorkspaceKeychainAddon()) {
+    if (!addon)
+        return { available: false, id: null };
+    try {
+        const entry = new addon.Entry(WORKSPACE_KEYCHAIN_SERVICE, account);
+        const raw = entry.getPassword();
+        const id = typeof raw === 'string' ? raw.trim() : '';
+        return WORKSPACE_ID_RE.test(id) ? { available: true, id } : { available: true, id: null };
+    }
+    catch (err) {
+        return isWorkspaceKeychainNoEntryError(err)
+            ? { available: true, id: null }
+            : { available: false, id: null };
+    }
+}
+export function writeToWorkspaceKeychain(account, id, addon = loadWorkspaceKeychainAddon()) {
+    if (!addon || !WORKSPACE_ID_RE.test(id))
+        return false;
+    try {
+        const entry = new addon.Entry(WORKSPACE_KEYCHAIN_SERVICE, account);
+        entry.setPassword(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const defaultWorkspaceKeychain = {
+    loadAddon: loadWorkspaceKeychainAddon,
+    readFromKeychain: (account) => readFromWorkspaceKeychain(account),
+    writeToKeychain: (account, id) => writeToWorkspaceKeychain(account, id),
+    getMode: getWorkspaceKeychainMode,
+};
+export function workspaceIdPath(workspaceRoot) {
+    return join(workspaceRoot, '.evolver', 'workspace-id');
+}
+export function resolveWorkspaceRootForIdentity(opts = {}) {
+    const env = opts.env ?? process.env;
+    const explicit = env['EVOLVER_REPO_ROOT']?.trim();
+    if (explicit)
+        return workspaceRootForRepo(resolve(explicit));
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    const repoRoot = findNearestGitRoot(cwd);
+    return workspaceRootForRepo(repoRoot ?? cwd);
+}
+export function resolveWorkspaceId(opts = {}) {
+    const env = opts.env ?? process.env;
+    const override = env['EVOLVER_WORKSPACE_ID']?.trim();
+    if (override)
+        return override;
+    const workspaceRoot = resolve(opts.workspaceRoot ?? resolveWorkspaceRootForIdentity({ env, cwd: opts.cwd }));
+    const file = workspaceIdPath(workspaceRoot);
+    const keychain = opts.keychain ?? defaultWorkspaceKeychain;
+    const mode = keychain.getMode(env);
+    if (mode !== 'off') {
+        const addonAvailable = keychain.loadAddon() !== null;
+        if (mode === 'force' && !addonAvailable) {
+            throw new Error('EVOLVER_WORKSPACE_KEYCHAIN=force but @napi-rs/keyring is not installed or unavailable.');
+        }
+        if (addonAvailable) {
+            const hit = keychain.readFromKeychain(workspaceRoot);
+            if (hit.available && hit.id)
+                return hit.id;
+            if (!hit.available && mode !== 'force') {
+                return readWorkspaceIdFromFs(file);
+            }
+            if (mode === 'force') {
+                if (!hit.available) {
+                    throw new Error('EVOLVER_WORKSPACE_KEYCHAIN=force: keychain reports unavailable; refusing filesystem fallback.');
+                }
+                const fresh = randomWorkspaceId();
+                if (!keychain.writeToKeychain(workspaceRoot, fresh)) {
+                    throw new Error('EVOLVER_WORKSPACE_KEYCHAIN=force: keychain write failed; refusing filesystem fallback.');
+                }
+                return fresh;
+            }
+            const fsId = readWorkspaceIdFromFs(file);
+            if (fsId) {
+                keychain.writeToKeychain(workspaceRoot, fsId);
+                return fsId;
+            }
+            const fresh = writeWorkspaceIdToFs(file);
+            if (!fresh)
+                return null;
+            keychain.writeToKeychain(workspaceRoot, fresh);
+            return fresh;
+        }
+    }
+    const existing = readWorkspaceIdFromFs(file);
+    if (existing)
+        return existing;
+    return writeWorkspaceIdToFs(file);
+}
+export function readWorkspaceIdFromFs(file) {
+    return readWorkspaceIdFile(file).id;
+}
+function readWorkspaceIdFile(file) {
+    try {
+        const dirStat = safeLstat(dirname(file));
+        if (dirStat?.isSymbolicLink())
+            return { id: null, repairableInvalid: false };
+        const fileStat = safeLstat(file);
+        if (!fileStat || fileStat.isSymbolicLink() || !fileStat.isFile())
+            return { id: null, repairableInvalid: false };
+        const raw = readFileSync(file, 'utf8').trim();
+        if (WORKSPACE_ID_RE.test(raw))
+            return { id: raw, repairableInvalid: false };
+        return { id: null, repairableInvalid: raw.length >= 32 };
+    }
+    catch {
+        return { id: null, repairableInvalid: false };
+    }
+}
+export function writeWorkspaceIdToFs(file, id = randomWorkspaceId()) {
+    if (!WORKSPACE_ID_RE.test(id))
+        return null;
+    try {
+        const dir = dirname(file);
+        const dirStat = safeLstat(dir);
+        if (dirStat?.isSymbolicLink())
+            return null;
+        mkdirSync(dir, { recursive: true });
+        const flags = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0);
+        let fd;
+        try {
+            fd = openSync(file, flags, 0o600);
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                return null;
+            const existing = readWorkspaceIdFile(file);
+            if (existing.id)
+                return existing.id;
+            return existing.repairableInvalid ? repairInvalidWorkspaceIdFile(file, id) : null;
+        }
+        try {
+            writeSync(fd, `${id}\n`, 0, 'utf8');
+        }
+        finally {
+            closeSync(fd);
+        }
+        try {
+            chmodSync(file, 0o600);
+        }
+        catch { /* best-effort on Windows */ }
+        return id;
+    }
+    catch {
+        return null;
+    }
+}
+function repairInvalidWorkspaceIdFile(file, id) {
+    try {
+        const dirStat = safeLstat(dirname(file));
+        if (dirStat?.isSymbolicLink())
+            return null;
+        const fileStat = safeLstat(file);
+        if (!fileStat || fileStat.isSymbolicLink() || !fileStat.isFile())
+            return null;
+        const fd = openWorkspaceIdForRepair(file);
+        try {
+            writeSync(fd, `${id}\n`, 0, 'utf8');
+        }
+        finally {
+            closeSync(fd);
+        }
+        try {
+            chmodSync(file, 0o600);
+        }
+        catch { /* best-effort on Windows */ }
+        return id;
+    }
+    catch {
+        return null;
+    }
+}
+function openWorkspaceIdForRepair(file) {
+    const noFollow = constants.O_NOFOLLOW;
+    if (typeof noFollow === 'number') {
+        return openSync(file, constants.O_WRONLY | constants.O_TRUNC | noFollow);
+    }
+    return openSync(file, 'w', 0o600);
+}
+function randomWorkspaceId() {
+    return randomBytes(16).toString('hex');
+}
+function safeLstat(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+function findNearestGitRoot(start) {
+    let dir = resolve(start);
+    for (;;) {
+        if (safeLstat(join(dir, '.git')))
+            return dir;
+        if (basename(dir) === 'node_modules')
+            return null;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function workspaceRootForRepo(repoRoot) {
+    const workspace = join(repoRoot, 'workspace');
+    const st = safeLstat(workspace);
+    return st?.isDirectory() ? workspace : repoRoot;
+}

package/dist/connect.js

@@ -6,6 +6,7 @@ import { LegacyAuthShim } from './auth/legacyShim.js';
 import { PublicOAuthProvider } from './auth/oauthDeviceToken.js';
 import { createOAuthHttpTransport } from './auth/oauthHttpTransport.js';
 import { KeypairProvider } from './auth/keypair.js';
+import { resolveWorkspaceId, resolveWorkspaceRootForIdentity } from './auth/workspaceKeychain.js';
 /** 选址装配公版 hub(M6-7): 按 authMode 组 AuthProvider(M6-5) + PublicHubCapability(M6-6). */
 export function connectPublicHub(opts) {
     const dir = opts.evomapDir ?? join(homedir(), '.evomap');
@@ -34,5 +35,18 @@ export function connectPublicHub(opts) {
             throw new Error(`未知 authMode: ${String(_x)}`);
         }
     }
-    return { hub: new PublicHubCapability({ baseUrl: opts.hubUrl, auth, fetchFn, senderId: opts.senderId, antiAbuse: opts.antiAbuse }), auth };
+    return { hub: new PublicHubCapability({ baseUrl: opts.hubUrl, auth, fetchFn, senderId: opts.senderId, antiAbuse: withWorkspaceIdResolver(opts.antiAbuse) }), auth };
+}
+function withWorkspaceIdResolver(antiAbuse) {
+    if (antiAbuse?.workspaceId || antiAbuse?.workspaceIdResolver)
+        return antiAbuse;
+    const env = antiAbuse?.env ?? process.env;
+    let workspaceRoot;
+    return {
+        ...(antiAbuse ?? {}),
+        workspaceIdResolver: () => {
+            workspaceRoot ??= resolveWorkspaceRootForIdentity({ env });
+            return resolveWorkspaceId({ env, workspaceRoot });
+        },
+    };
 }

package/dist/hubCapability.d.ts

@@ -30,6 +30,32 @@ export interface OutcomeReceipt {
     recorded: boolean;
     reason?: string;
 }
+export type MemoryGraphEventKind = 'attempt' | 'validation' | 'skill_emit' | 'outcome' | 'mutation_draft' | 'solidify';
+export interface MemoryGraphEventReport {
+    kind: MemoryGraphEventKind;
+    event: Record<string, unknown>;
+}
+/** recordMemoryEvent never throws: failures come back as `recorded:false` + reason. */
+export interface MemoryGraphEventReceipt {
+    recorded: boolean;
+    reason?: string;
+}
+export type AccountAssetScope = 'purchased' | 'published';
+export type AccountAssetTypeFilter = 'Gene' | 'Capsule';
+export type AccountAssetStatusFilter = 'draft' | 'promoted' | 'all';
+export interface AccountAssetListOptions {
+    scope: AccountAssetScope;
+    type?: AccountAssetTypeFilter;
+    status?: AccountAssetStatusFilter;
+    limit?: number;
+    cursor?: string;
+}
+export interface AccountAssetListResult {
+    assets: hub.AssetRecord[];
+    count?: number;
+    hasMore: boolean;
+    nextCursor?: string;
+}
 /** 完整 GEP-A2A 信封(实测 dev: publish/fetch/validate 等协议消息端点必须全信封, 非仅 protocol+message_type). */
 export declare function gepEnvelope(messageType: string, payload: unknown): Record<string, unknown>;
 export interface PublicHubOptions {
@@ -55,6 +81,12 @@ export interface PublicHelloResult {
     httpStatus?: number;
     secretDiverged?: boolean;
 }
+export interface PublicHelloOptions {
+    rotate: boolean;
+    evolverVersion?: string;
+    /** Keep trust probes from adopting or clearing local credential state. */
+    preserveCredentials?: boolean;
+}
 export interface PublicHeartbeatOptions {
     evolverVersion?: string;
     lastUpdate?: PublicLastUpdatePayload;
@@ -103,10 +135,7 @@ export declare class PublicHubCapability implements hub.HubCapability {
     readonly auth: hub.AuthProvider;
     readonly recipes: hub.RecipeCapability;
     constructor(opts: PublicHubOptions);
-    hello(opts: {
-        rotate: boolean;
-        evolverVersion?: string;
-    }): Promise<PublicHelloResult>;
+    hello(opts: PublicHelloOptions): Promise<PublicHelloResult>;
     heartbeat(opts?: PublicHeartbeatOptions): Promise<PublicHeartbeatResult>;
     private heartbeatMeta;
     publish(bundle: hub.AssetRecord[]): Promise<hub.PublishReceipt>;
@@ -117,6 +146,8 @@ export declare class PublicHubCapability implements hub.HubCapability {
      * signals/id queries fall through to fetch. /a2a/fetch does NOT do semantic, so text must not go there.
      */
     search(query: hub.HubQuery): Promise<hub.AssetRecord[]>;
+    agentDirectory: hub.AgentDirectoryCapability;
+    listAccountAssets(opts: AccountAssetListOptions): Promise<AccountAssetListResult>;
     /**
      * Report a cycle outcome to the hub's memory graph (POST /a2a/memory/record).
      * Unlike the protocol-message endpoints (publish/fetch), memory/record takes a
@@ -126,6 +157,7 @@ export declare class PublicHubCapability implements hub.HubCapability {
      * Costs hub credits per the hub's memory pricing (caller gates on enablement).
      */
     recordOutcome(report: OutcomeReport): Promise<OutcomeReceipt>;
+    recordMemoryEvent(report: MemoryGraphEventReport): Promise<MemoryGraphEventReceipt>;
     recordReuseResult(report: hub.ReuseResultReport): Promise<hub.ReuseResultReceipt>;
     /**
      * Pre-publish dry-run (POST /a2a/validate). The hub runs the same hub-side quality +
@@ -146,7 +178,7 @@ export declare class PublicHubCapability implements hub.HubCapability {
         claim: (taskId: string) => Promise<{
             claimId: string;
         }>;
-        complete: (claimId: string, result: unknown) => Promise<{
+        complete: (claimId: string, _result: unknown, context?: hub.TaskCompleteContext) => Promise<{
             status: "completed";
         }>;
         subscribe: (filter: unknown) => AsyncIterable<hub.TaskEvent>;

package/dist/hubCapability.js

@@ -1,13 +1,15 @@
-import { hub as hubNs } from '@evomap/evolver-core';
+import { bootstrap, hub as hubNs } from '@evomap/evolver-core';
 import { AuthError, HubFetch, HubClientError, isHubUnreachableError } from './hubFetch.js';
 import { isNodeSecret, parseNodeSecretVersion } from './auth/legacyShim.js';
 import { inboundToAgentEvent, agentEventToOutbound, publishRespToReceipt, searchQueryToFetchWire } 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';
 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'];
+export const PUBLIC_HUB_CAPABILITIES = ['publish', 'fetch', 'search', 'task', 'mailbox', 'auth', 'marketplace', 'economy', 'questions', 'recipes', 'agent_directory'];
 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']);
@@ -101,6 +103,11 @@ export class PublicHubCapability {
                 timestamp: new Date().toISOString(),
                 ...(sender ? { node_id: sender } : {}),
                 ...(opts.evolverVersion ? { evolver_version: opts.evolverVersion } : {}),
+                // v1 parity (a2aProtocol.js buildHello): every hello carries the env fingerprint — it is how the
+                // hub builds node/IP trust for its anti-abuse layer. v2 had moved it to heartbeat-only meta, which
+                // one-shot CLI paths never send; the hub then answers heartbeats with resend_hello
+                // `missing_env_fingerprint` and 403-antibodies /a2a/fetch (#555).
+                env_fingerprint: bootstrap.captureEnvFingerprint({ env: this.opts.antiAbuse?.env ?? process.env }),
             }));
             const payload = asRecord(body['payload']) ?? body;
             const retryAfterMs = numberField(payload, 'retry_after_ms') ?? numberField(payload, 'retryAfterMs');
@@ -113,10 +120,12 @@ export class PublicHubCapability {
             // cleanly; retrying with the diverged secret never can. Signals the caller NOT to arm reauth
             // backoff. Only legacy node_secret auth exposes this hook — enterprise_token is a no-op.
             if (isSecretDivergenceRejection(body, payload)) {
-                this.auth.notifyNodeSecretDiverged?.();
+                if (!opts.preserveCredentials) {
+                    this.auth.notifyNodeSecretDiverged?.();
+                }
                 return {
                     ok: false,
-                    error: 'secret_diverged_cleared',
+                    error: opts.preserveCredentials ? 'secret_diverged' : 'secret_diverged_cleared',
                     secretDiverged: true,
                     ...(rateLimitUntilMs !== undefined ? { rateLimitUntilMs } : {}),
                     ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
@@ -132,11 +141,13 @@ export class PublicHubCapability {
                 ?? this.opts.senderId();
             const nodeSecret = stringField(payload, 'node_secret') ?? stringField(payload, 'nodeSecret');
             const nodeSecretVersion = parseNodeSecretVersion(payload['node_secret_version'] ?? payload['nodeSecretVersion']);
-            if (nodeSecret && isNodeSecret(nodeSecret)) {
-                this.auth.adoptNodeSecret?.(nodeSecret, nodeSecretVersion);
-            }
-            else {
-                this.auth.adoptNodeSecretVersion?.(nodeSecretVersion);
+            if (!opts.preserveCredentials) {
+                if (nodeSecret && isNodeSecret(nodeSecret)) {
+                    this.auth.adoptNodeSecret?.(nodeSecret, nodeSecretVersion);
+                }
+                else {
+                    this.auth.adoptNodeSecretVersion?.(nodeSecretVersion);
+                }
             }
             return {
                 ok: payload['ok'] !== false && Boolean(nodeId),
@@ -194,7 +205,9 @@ export class PublicHubCapability {
                     evolverVersion: opts.evolverVersion,
                 });
             }
-            catch {
+            catch (err) {
+                if (getWorkspaceKeychainMode(antiAbuse.env) === 'force')
+                    throw err;
                 process.stderr.write('[anti-abuse] failed to build heartbeat telemetry; continuing without heartbeat meta\n');
             }
         }
@@ -241,6 +254,78 @@ export class PublicHubCapability {
         }
         return this.fetch(query);
     }
+    agentDirectory = {
+        search: async (request) => {
+            try {
+                const normalized = hubNs.normalizeAgentSearchRequest(request);
+                const unsupported = unsupportedPublicAvailability(normalized.availability) ?? unsupportedPublicSort(normalized.sort);
+                if (unsupported)
+                    return unsupported;
+                const body = await withDirectoryTimeout(this.http.call('GET', '/a2a/directory/search', undefined, publicAgentSearchQuery(normalized)), normalized.timeoutMs);
+                return paginatePublicAgentPage(parsePublicAgentPage(body), normalized);
+            }
+            catch (error) {
+                return agentDirectoryFailure(error);
+            }
+        },
+        getProfile: async (agentId, options) => {
+            try {
+                const normalizedId = hubNs.normalizeAgentId(agentId);
+                const timeoutMs = hubNs.normalizeAgentDirectoryTimeout(options?.timeoutMs);
+                const body = await withDirectoryTimeout(this.http.call('GET', `/a2a/directory/profile/${encodeURIComponent(normalizedId)}`), timeoutMs);
+                return parsePublicAgentProfile(body);
+            }
+            catch (error) {
+                if (error instanceof HubClientError && error.status === 404)
+                    return { ok: true, value: null };
+                return agentDirectoryFailure(error);
+            }
+        },
+        discoverForTask: async (request) => {
+            try {
+                const normalized = hubNs.normalizeAgentTaskDiscoveryRequest(request);
+                const unsupported = unsupportedPublicAvailability(normalized.availability) ?? unsupportedPublicSort(normalized.sort);
+                if (unsupported)
+                    return unsupported;
+                const taskQuery = [normalized.title, normalized.description].filter(Boolean).join('\n');
+                const searches = [
+                    this.http.call('GET', '/a2a/directory/search', undefined, publicAgentSearchQuery({
+                        query: taskQuery,
+                        ...(normalized.availability ? { availability: normalized.availability } : {}),
+                    })),
+                ];
+                if (normalized.signals && normalized.signals.length > 0) {
+                    searches.push(this.http.call('GET', '/a2a/directory/search', undefined, publicTaskDiscoveryQuery(normalized)));
+                }
+                const bodies = await withDirectoryTimeout(Promise.all(searches), normalized.timeoutMs);
+                return paginatePublicAgentPage(mergePublicAgentPages(bodies.map(parsePublicAgentPage)), normalized, searches.length > 1 ? PUBLIC_TASK_DISCOVERY_MAX_CANDIDATES : hubNs.AGENT_DIRECTORY_MAX_LIMIT);
+            }
+            catch (error) {
+                return agentDirectoryFailure(error);
+            }
+        },
+    };
+    async listAccountAssets(opts) {
+        const path = opts.scope === 'purchased' ? '/a2a/assets/purchased' : '/a2a/assets/published-by-me';
+        const query = {
+            ...(opts.limit !== undefined ? { limit: opts.limit } : {}),
+            ...(opts.cursor ? { cursor: opts.cursor } : {}),
+            ...(opts.type ? { type: opts.type } : {}),
+            ...(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 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);
+        return {
+            assets,
+            ...(count !== undefined ? { count } : {}),
+            hasMore,
+            ...(nextCursor ? { nextCursor } : {}),
+        };
+    }
     /**
      * Report a cycle outcome to the hub's memory graph (POST /a2a/memory/record).
      * Unlike the protocol-message endpoints (publish/fetch), memory/record takes a
@@ -269,6 +354,24 @@ export class PublicHubCapability {
             return { recorded: false, reason: e instanceof Error ? e.message : String(e) };
         }
     }
+    async recordMemoryEvent(report) {
+        const sender = this.opts.senderId()?.trim();
+        if (!sender)
+            return { recorded: false, reason: 'sender_id_required' };
+        const event = asRecord(report.event);
+        if (!event)
+            return { recorded: false, reason: 'event_required' };
+        try {
+            await this.http.call('POST', '/a2a/memory/event', {
+                sender_id: sender,
+                event: { ...event, kind: report.kind },
+            });
+            return { recorded: true };
+        }
+        catch (e) {
+            return { recorded: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+    }
     async recordReuseResult(report) {
         const assetId = report.assetId.trim();
         if (!assetId)
@@ -398,11 +501,31 @@ export class PublicHubCapability {
     }
     task = {
         claim: async (taskId) => {
-            await this.http.call('POST', '/a2a/mailbox/outbound', { messages: [{ id: `claim-${taskId}`, type: 'task_claim', payload: { taskId } }] });
-            return { claimId: `claim-${taskId}` };
+            const event = {
+                id: `claim-${taskId}`,
+                type: 'task_claim',
+                payload: { task_id: taskId },
+                priority: 'medium',
+                createdAt: Date.now(),
+            };
+            const body = await this.http.call('POST', '/a2a/mailbox/outbound', { messages: [{ id: event.id, type: event.type, payload: event.payload }] });
+            assertMailboxPushAccepted(mailboxPushResultFromBody(body, [event]).outcomes[0]);
+            return { claimId: event.id };
         },
-        complete: async (claimId, result) => {
-            await this.http.call('POST', '/a2a/mailbox/outbound', { messages: [{ id: `complete-${claimId}`, type: 'task_complete', payload: { claimId, result } }] });
+        complete: async (claimId, _result, context) => {
+            if (typeof context?.taskId !== 'string' || !context.taskId.trim()
+                || typeof context.assetId !== 'string' || !context.assetId.trim()) {
+                throw new hubNs.PublishRejectedError('invalid_task_completion', true, 'task completion requires explicit taskId and assetId', undefined, false);
+            }
+            const event = {
+                id: `complete-${claimId}`,
+                type: 'task_complete',
+                payload: { task_id: context.taskId, asset_id: context.assetId },
+                priority: 'medium',
+                createdAt: Date.now(),
+            };
+            const body = await this.http.call('POST', '/a2a/mailbox/outbound', { messages: [{ id: event.id, type: event.type, payload: event.payload }] });
+            assertMailboxPushAccepted(mailboxPushResultFromBody(body, [event]).outcomes[0]);
             return { status: 'completed' };
         },
         subscribe: (filter) => this.subscribeTasks(filter),
@@ -449,10 +572,7 @@ export class PublicHubCapability {
         ack: async (eventId) => { await this.http.call('POST', '/a2a/mailbox/ack', { message_ids: [eventId] }); },
         push: async (event) => {
             const result = await this.mailbox.pushMany([event]);
-            const outcome = result?.outcomes.find((item) => item.id === event.id);
-            if (outcome?.status !== 'failed')
-                return;
-            throw new hubNs.PublishRejectedError('mailbox_push_rejected', outcome.terminal ?? outcome.retryable !== true, outcome.reason ?? 'mailbox_push_rejected', outcome.retryAfterMs, outcome.retryable);
+            assertMailboxPushAccepted(result?.outcomes.find((item) => item.id === event.id));
         },
         pushMany: async (events) => {
             if (events.length === 0)
@@ -599,7 +719,51 @@ function assetsFromBody(body) {
         ...(Array.isArray(payload?.['assets']) ? payload['assets'] : []),
         ...(Array.isArray(payload?.['results']) ? payload['results'] : []),
     ];
-    return candidates.filter((candidate) => Boolean(candidate && typeof candidate === 'object' && !Array.isArray(candidate)));
+    return candidates
+        .filter((candidate) => Boolean(candidate && typeof candidate === 'object' && !Array.isArray(candidate)))
+        .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'];
+/**
+ * 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
+ * delivery metadata (asset_type, bundle_id, confidence, gdi_score_mean, callable, …). Treating the
+ * row as the asset made reuse's integrity check (computeAssetId over the row) fail on every
+ * delivered asset. A GEP record always carries a string `type`; delivery rows carry `asset_type`
+ * instead — so unwrap exactly when the row has no `type` and nests an object payload that looks
+ * like a GEP record. Rows that already ARE raw records (older hubs, tests) pass through unchanged.
+ */
+function unwrapFetchDeliveryRow(row) {
+    const record = row;
+    if (typeof record['type'] === 'string')
+        return row;
+    const inner = asRecord(record['payload']);
+    if (!inner || typeof inner['type'] !== 'string' || typeof inner['asset_id'] !== 'string')
+        return row;
+    const carryover = {};
+    for (const key of FETCH_ROW_CARRYOVER_KEYS) {
+        if (record[key] !== undefined && inner[key] === undefined)
+            carryover[key] = record[key];
+    }
+    return { ...inner, ...carryover };
+}
+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)));
+    }
+    return [];
 }
 function assetMatchesId(asset, assetId) {
     return Boolean(asset && (asset.asset_id === assetId || stringField(asset, 'id') === assetId));
@@ -666,6 +830,11 @@ function splitMailboxOutboundBatches(events) {
         out.push({ events: batch });
     return out;
 }
+function assertMailboxPushAccepted(outcome) {
+    if (outcome?.status !== 'failed')
+        return;
+    throw new hubNs.PublishRejectedError('mailbox_push_rejected', outcome.terminal ?? outcome.retryable !== true, outcome.reason ?? 'mailbox_push_rejected', outcome.retryAfterMs, outcome.retryable);
+}
 function mailboxPushResultFromBody(body, events) {
     const results = mailboxResultRows(body);
     if (results.length === 0) {
@@ -690,16 +859,32 @@ function mailboxPushOutcomeFromRow(eventId, results, index) {
         })();
     const retryable = booleanField(match, 'retryable');
     const terminal = booleanField(match, 'terminal');
+    const inferredTerminal = retryable === undefined && terminal === undefined
+        ? isKnownTerminalMailboxFailure(match, reason)
+        : undefined;
     return {
         id: eventId,
         status: 'failed',
         reason,
-        ...(retryable !== undefined ? { retryable } : {}),
-        ...(terminal !== undefined ? { terminal } : {}),
+        ...(retryable !== undefined ? { retryable } : inferredTerminal === false ? { retryable: true } : {}),
+        ...(terminal !== undefined ? { terminal } : inferredTerminal !== undefined ? { terminal: inferredTerminal } : {}),
         ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
         raw: match,
     };
 }
+function isKnownTerminalMailboxFailure(row, reason) {
+    const status = stringField(row, 'status')?.toLowerCase() ?? '';
+    if (status.includes('reject') || status.includes('invalid') || status === 'quarantine')
+        return true;
+    const normalizedReason = reason.toLowerCase();
+    const alreadySubmittedCode = 'already_submitted_for_task';
+    if (normalizedReason === alreadySubmittedCode
+        || normalizedReason.startsWith(`${alreadySubmittedCode}:`)
+        || normalizedReason === 'orphan_node_not_allowed_for_bounty')
+        return true;
+    return /\binvalid[_ -]|validation[_ -]?error|payload[_ -]?too[_ -]?large|not[_ -]?found|expired|already[_ -]?(claimed|completed)|duplicate|conflict|not[_ -]?(task[_ -]?(owner|claimer)|asset[_ -]?owner|open|active|claimed|eligible)|asset[_ -]?(orphaned|not[_ -]?promoted)|task[_ -]?full|node[_ -]?(suspended|merging|dead)|insufficient[_ -]?(reputation|model[_ -]?tier)|task[_ -]?reserved[_ -]?for[_ -]?preferred[_ -]?merchant|atp[_ -]?requires[_ -]?evolver[_ -]?version|self[_ -]?funded[_ -]?bounty[_ -]?self[_ -]?claim/i
+        .test(reason);
+}
 // A 413 (payload too large) or 429 (rate-limited) can surface either as a JSON
 // HubClientError, OR — when an ingress/gateway (Envoy/nginx) emits a non-JSON
 // body — as a HubUnreachableError carrying the HTTP status in `details.status`

package/dist/hubReuse.d.ts

@@ -1,5 +1,4 @@
-import { hub } from '@evomap/evolver-core';
-import type { algo } from '@evomap/evolver-core';
+import { hub, algo } from '@evomap/evolver-core';
 type HubMetadata = hub.HubMetadata;
 type ReuseDecision = hub.ReuseDecision;
 type GeneCandidateInput = algo.GeneCandidateInput;

package/dist/hubReuse.js

@@ -12,7 +12,7 @@
 //   - search cache: signal-fingerprint → phase-1 metadata (short TTL). Repeat signal set → ZERO hub calls.
 //   - payload cache: assetId → phase-3 payload (content-addressed, long/permanent, bounded LRU). A cached
 //     payload → ZERO fetch. Both clocks are injected so TTL/eviction is deterministic and testable.
-import { hub } from '@evomap/evolver-core';
+import { hub, algo } from '@evomap/evolver-core';
 const { scoreSearchResults, decideReuse, DEFAULT_MIN_REUSE_SCORE, } = hub;
 const GENE_WIRE_KEYS = new Set([
     'type',
@@ -30,6 +30,7 @@ const GENE_WIRE_KEYS = new Set([
     'anti_patterns',
     'routing_hint',
     'tool_policy',
+    'generation_meta',
     'asset_id',
 ]);
 // ── Cache config (ported from v1 hubSearch.js) ───────────────────────────────
@@ -163,6 +164,7 @@ export function toGeneCandidate(rec) {
     const geneId = typeof r['id'] === 'string' ? r['id'] : assetId;
     const signalsMatch = strArr(r['signals_match'] ?? r['signalsMatch']) ?? [];
     const reuseCount = num(r['reuse_count'] ?? r['reuseCount']) ?? 0;
+    const generationSource = algo.geneGenerationSource(r, geneId);
     return {
         geneId,
         assetId,
@@ -173,6 +175,7 @@ export function toGeneCandidate(rec) {
         reuseCount,
         ...(typeof r['category'] === 'string' ? { category: r['category'] } : {}),
         ...(typeof r['summary'] === 'string' ? { summary: r['summary'] } : {}),
+        ...(generationSource ? { generationSource } : {}),
         hubAsset: stripHubPayloadMetadata(rec),
     };
 }

package/dist/hubUrl.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_PUBLIC_HUB_URL = "https://evomap.ai";
+export type HubUrlEnv = Record<string, string | undefined>;
+export declare function resolveConfiguredHubUrl(env: HubUrlEnv): string | undefined;
+export declare function resolveHubUrl(env: HubUrlEnv): string;

package/dist/hubUrl.js

@@ -0,0 +1,20 @@
+export const DEFAULT_PUBLIC_HUB_URL = 'https://evomap.ai';
+const HUB_URL_KEYS = ['A2A_HUB_URL', 'EVOMAP_HUB_URL', 'EVOLVER_DEFAULT_HUB_URL'];
+function normalizeHubUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.replace(/\/+$/, '');
+    return normalized || undefined;
+}
+export function resolveConfiguredHubUrl(env) {
+    for (const key of HUB_URL_KEYS) {
+        const resolved = normalizeHubUrl(env[key]);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+export function resolveHubUrl(env) {
+    return resolveConfiguredHubUrl(env) ?? DEFAULT_PUBLIC_HUB_URL;
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export declare const PACKAGE = "@evomap/evolver-adapter-public";
 export * from './auth/machineId.js';
+export * from './auth/workspaceKeychain.js';
 export * from './auth/credentialStore.js';
 export * from './auth/keypair.js';
 export * from './auth/legacyShim.js';
@@ -8,9 +9,11 @@ export * from './auth/oauthHttpTransport.js';
 export * from './hubFetch.js';
 export * from './wireMap.js';
 export * from './hubCapability.js';
+export * from './agentDirectory.js';
 export * from './antiAbuseTelemetry.js';
 export * from './offlinePermit.js';
 export * from './hubReuse.js';
+export * from './hubUrl.js';
 export * from './atp.js';
 export * from './pricing/modelPrices.js';
 export * from './connect.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export const PACKAGE = '@evomap/evolver-adapter-public';
 export * from './auth/machineId.js';
+export * from './auth/workspaceKeychain.js';
 export * from './auth/credentialStore.js';
 export * from './auth/keypair.js';
 export * from './auth/legacyShim.js';
@@ -8,9 +9,11 @@ export * from './auth/oauthHttpTransport.js';
 export * from './hubFetch.js';
 export * from './wireMap.js';
 export * from './hubCapability.js';
+export * from './agentDirectory.js';
 export * from './antiAbuseTelemetry.js';
 export * from './offlinePermit.js';
 export * from './hubReuse.js';
+export * from './hubUrl.js';
 export * from './atp.js';
 export * from './pricing/modelPrices.js';
 export * from './connect.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-adapter-public",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.10",
   "private": false,
   "type": "module",
   "description": "公版 hub 适配器 (积分/治理)",
@@ -14,15 +14,23 @@
   },
   "dependencies": {
     "@evomap/atp-sdk": "^0.1.0",
-    "@evomap/evolver-core": "2.0.0-beta.1",
+    "@evomap/evolver-core": "2.0.0-beta.10",
     "undici": "^6.27.0"
   },
+  "optionalDependencies": {
+    "@napi-rs/keyring": "^1.1.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EvoMap/evolver.git"
+  },
   "publishConfig": {
     "access": "public",
     "tag": "v2-beta"
   },
   "files": [
     "dist/",
+    "assets/",
     "README.md",
     "package.json"
   ]