@evomap/evolver-core 2.0.0-beta.0

package/dist/hub/capability.d.ts

@@ -0,0 +1,278 @@
+import type { AssetRecord, AssetKind, SearchQuery, PutResult } from '../assetstore/provider.js';
+import type { Envelope } from '../mailbox/envelope.js';
+/** publish 投递回执. hub 侧做 gate(经济/治理/RBAC 全在 hub), core 只读 status+reason. */
+export interface PublishReceipt {
+    /** hub 返回的回执 id(公版=AgentEvent/decision id; 私有=审计 id). */
+    receiptId: string;
+    /** hub gate 决议. quarantine 仅公版可能出现, core 当 rejected 的软态处理. */
+    status: 'accepted' | 'rejected' | 'quarantine';
+    /** rejected/quarantine 时的人读原因(core 不解释经济/治理语义, 原样回灌 Material). */
+    reason?: string;
+    /** hub 计算后的 asset_id(必须与 core normalizeForPut 逐字节一致, 命门, conformance 校验). */
+    assetId?: string;
+    /** bundle 发布: hub 返回的 bundle_id + 全资产 asset_id(实测公版 /a2a/publish 收 [Gene,Capsule,Event] 捆绑). */
+    bundleId?: string;
+    assetIds?: string[];
+    /** 终态标记: true=不可重试(reject/quarantine/402), SyncEngine 不得 incrementRetry(money-safety risk). */
+    terminal?: boolean;
+    /** M8-1: 公版经济侧只读回执(core 不解释经济语义, 仅透传供观测/UI). private hub 多为空. */
+    economic?: {
+        creditShortage?: boolean;
+        required?: number;
+        available?: number;
+        balanceKind?: 'user_balance' | 'node_balance';
+        gdiScore?: number;
+    };
+}
+/** 资产查询. 复用 assetstore SearchQuery, 不发明第二套查询 DSL. */
+export type HubQuery = SearchQuery;
+/** task 子系统事件(订阅流元素). 公版含经济上下文(bounty/credit), 私有仅 workflow. */
+export interface TaskEvent {
+    taskId: string;
+    type: string;
+    payload: unknown;
+    priority: 'high' | 'medium' | 'low';
+    createdAt: number;
+}
+/** Proactive Hub question that a runtime may submit for ecosystem help. */
+export interface HubQuestion {
+    question: string;
+    amount?: number;
+    signals?: readonly string[];
+}
+/** Flexible receipt for hubs that turn submitted questions into tasks/bounties. */
+export interface QuestionSubmitReceipt {
+    question?: string;
+    taskId?: string;
+    bountyId?: string;
+    error?: string;
+    raw?: unknown;
+}
+/** mailbox 通用事件. inbound 用 hub 原始 wire shape, 由 adapter 翻成 core Envelope 落 MailboxStore. */
+export interface AgentEvent {
+    id: string;
+    type: string;
+    payload: unknown;
+    priority: 'high' | 'medium' | 'low';
+    cursor?: string;
+    createdAt: number;
+    refId?: string;
+    expiresAt?: number;
+}
+export interface MailboxPushOutcome {
+    id: string;
+    status: 'accepted' | 'failed';
+    reason?: string;
+    retryable?: boolean;
+    terminal?: boolean;
+    retryAfterMs?: number;
+    raw?: unknown;
+}
+export interface MailboxPushManyResult {
+    outcomes: MailboxPushOutcome[];
+}
+/**
+ * mailbox.poll 结果. **焊入短轮询背压**(对应 hub issue #1195 的 next_poll_after_ms 提案):
+ * hub 给出建议的下次轮询间隔, SyncEngine 优先遵守(有事件→0/有 backlog→小, 空→大, 降载→更大),
+ * 缺省时回退 SyncEngine 默认节奏. 这让 adapter 对 hub 长轮询→短轮询迁移**零改动前向兼容**.
+ */
+export interface MailboxPollResult {
+    events: AgentEvent[];
+    /** hub 建议下次 poll 间隔 ms(#1195). 缺省=adapter 用默认节奏. */
+    nextPollAfterMs?: number;
+    /** 还有更多 backlog 未拉完 → adapter 应 drain 而非 idle(防限流饿死). */
+    hasMore?: boolean;
+}
+export type ReuseResultOutcome = 'success' | 'failed' | 'mismatched' | 'stale' | 'unsafe';
+/** Reuse outcome report. Hub owns attribution, RBAC, and audit policy; runtime only forwards the claim. */
+export interface ReuseResultReport {
+    assetId: string;
+    outcome: ReuseResultOutcome;
+    taskId?: string;
+    traceId?: string;
+    /** Deprecated compatibility field. A scalar without measurement metadata is self-reported and must not count as ROI. */
+    tokensSaved?: number;
+    timeSavedSeconds?: number;
+    reason?: string;
+}
+/** Reuse-result reporting is best-effort; failures must not break fetch or solve paths. */
+export interface ReuseResultReceipt {
+    recorded: boolean;
+    reason?: string;
+    id?: string;
+}
+/**
+ * Pre-publish dry-run result. The hub runs the same hub-side quality + content-safety
+ * gate as publish but stores nothing and charges no credits, so an agent can check a
+ * bundle before paying to publish. Proxy callers sanitize and leak-check before invoking
+ * hub validate, mirroring the publish path. A dry-run is never a dependency of a cycle,
+ * so the adapter degrades every failure (quality/safety reject, 5xx, network) to
+ * valid:false.
+ */
+export interface ValidateReceipt {
+    valid: boolean;
+    /** Human-readable rejection cause when valid:false (hub quality/safety reason, or transport error). */
+    reason?: string;
+    /** hub 原始 payload 透传(target_asset_id / content_safety_warning / privacy_guidance 等); core 不解释. */
+    raw?: unknown;
+}
+export type RecipeAssetType = 'Gene' | 'Capsule';
+/** A recipe step references an owned Gene/Capsule asset by content id. */
+export interface RecipeStep {
+    assetId: string;
+    assetType: RecipeAssetType;
+    position?: number;
+}
+/** Create a draft recipe; publishing is a separate explicit action. */
+export interface RecipeCreateRequest {
+    title: string;
+    steps: readonly RecipeStep[];
+    description?: string;
+    pricePerExecution?: number;
+    currency?: string;
+    maxConcurrent?: number;
+}
+export interface RecipeReceipt {
+    recipeId?: string;
+    status?: string;
+    raw: unknown;
+}
+export interface RecipeFetchReceipt extends RecipeReceipt {
+    recipe?: unknown;
+}
+export interface RecipeExpressRequest {
+    inputPayload?: Record<string, unknown>;
+}
+export interface RecipeExpressionReceipt extends RecipeReceipt {
+    organismId?: string;
+}
+/** Optional Hub recipe/DNA capability. Core stays wire-agnostic; adapters own REST shape. */
+export interface RecipeCapability {
+    create(request: RecipeCreateRequest): Promise<RecipeReceipt>;
+    publish(recipeId: string): Promise<RecipeReceipt>;
+    get(recipeId: string): Promise<RecipeFetchReceipt>;
+    express(recipeId: string, request?: RecipeExpressRequest): Promise<RecipeExpressionReceipt>;
+}
+export type HubCapabilityName = 'publish' | 'fetch' | 'search' | 'task' | 'mailbox' | 'auth' | 'audit' | 'air_gap' | 'tenant_isolation' | 'marketplace' | 'economy' | 'questions' | 'recipes';
+/** hub 能力清单(可选). core 据此动态适配 UI/行为, "按需耦合". */
+export interface HubManifest {
+    capabilities: HubCapabilityName[] | string[];
+    protocolVersion: string;
+    economyEnabled?: boolean;
+    authKinds?: CredentialKind[];
+    /** enterprise/public 差异表达为能力与策略, core 不分支判断 edition/repo. */
+    auditEnabled?: boolean;
+    airGap?: boolean;
+    tenantIsolation?: boolean;
+    marketplaceAccess?: boolean;
+}
+export type CredentialKind = 'oauth_device_token' | 'keypair' | 'enterprise_sso';
+export type Credential = {
+    id: string;
+    kind: CredentialKind;
+    device?: string;
+    publicKey?: string;
+    expiresAt?: number;
+    refreshToken?: string;
+} & ({
+    token: string;
+} | {
+    privateKey: string;
+});
+/** 给一个待发请求加凭证/签名后的结果(adapter 注入 HTTP 层). */
+export interface SignedRequest {
+    headers: Record<string, string>;
+    bodySignature?: string;
+    /** 注入请求体的凭证字段(gep-a2a: node_secret 走 body 而非 header — 实测 dev 契约). */
+    bodyFields?: Record<string, unknown>;
+}
+/** 待签请求的最小描述. */
+export interface HttpRequestLike {
+    method: string;
+    path: string;
+    body?: string;
+}
+/**
+ * Pluggable auth. Example implementations: public OAuth device token / Ed25519 keypair / enterprise SSO (OIDC/LDAP).
+ * node_secret dual-track transition is wrapped by LegacyAuthShim. (The enterprise SSO impl lives in the enterprise repo; the public repo only defines the interface.)
+ */
+export interface AuthProvider {
+    kind: CredentialKind;
+    /** 首次认证: 浏览器 OAuth / device code flow / 无头 keypair. 持久化到 ~/.evomap. */
+    login(): Promise<Credential>;
+    /** 给请求加凭证/签名(每个出站 HTTP 调一次). 审计级动作必须 keypair 签 body. */
+    authenticate(req: HttpRequestLike): Promise<SignedRequest>;
+    /** 轮换. token 自动(提前 6h); keypair 用旧私钥签 revoke 后换新. */
+    rotate(): Promise<Credential>;
+    /** 撤销凭证(机器丢失/泄露). */
+    revoke(credentialId: string): Promise<void>;
+}
+export interface HubCapability {
+    /**
+     * 异步发布. 公版 /a2a/publish 收 **bundle**[Gene,Capsule,(EvolutionEvent)](一个 cycle 的产物一起发, +GDI);
+     * 传单资产=[asset]。core 已 normalizeForPut(算/校验 asset_id), hub 做经济/治理/质量 gate。
+     */
+    publish(bundle: AssetRecord[]): Promise<PublishReceipt>;
+    /** 拉取资产. hub 侧排序/scope(公版 GDI, 私有 RBAC); core 不重排. */
+    fetch(query: HubQuery): Promise<AssetRecord[]>;
+    /** 搜索资产. 与 fetch 同 shape, 差异在 hub 侧召回策略. */
+    search(query: HubQuery): Promise<AssetRecord[]>;
+    /** 可选: 按 content-addressed asset_id 拉单个 full asset. private adapter/proxy 用它保证只 fetch 一个 winner. */
+    fetchAssetById?(assetId: string): Promise<AssetRecord | null>;
+    /** 可选: 报告某个资产被复用后的结果. PHub/enterprise adapter 实现; 不支持时 runtime 应明确降级. */
+    recordReuseResult?(report: ReuseResultReport): Promise<ReuseResultReceipt>;
+    /**
+     * 可选: 发布前 dry-run 校验(公版 POST /a2a/validate). 跑与 publish 相同的 hub 端质量门禁 + 内容安全扫描,
+     * 但不落库、不计费; 经由 Proxy 暴露时调用方需先执行与 publish 相同的客户端脱敏/泄漏拦截.
+     * 让 agent 在花 credits 发布前先确认. 不支持的 hub 不实现此方法; proxy/runtime 据此降级.
+     */
+    validate?(bundle: AssetRecord[]): Promise<ValidateReceipt>;
+    /** task 子系统. 公版含经济(在 hub), 私有仅内部 workflow; core 两边同接口. */
+    task: {
+        claim(taskId: string): Promise<{
+            claimId: string;
+        }>;
+        complete(claimId: string, result: unknown): Promise<{
+            status: 'completed';
+        }>;
+        subscribe(filter: unknown): AsyncIterable<TaskEvent>;
+    };
+    /** Optional proactive question seam. Public Hub currently accepts these on /a2a/fetch payload.questions. */
+    questions?: {
+        submit(questions: readonly HubQuestion[]): Promise<QuestionSubmitReceipt[]>;
+    };
+    /** Optional recipe/DNA seam. Recipe creation is draft-first; publishing remains explicit. */
+    recipes?: RecipeCapability;
+    /** mailbox 队列. poll/ack/push/status 四端点解耦(公版 /a2a/mailbox/*). */
+    mailbox: {
+        poll(): Promise<MailboxPollResult>;
+        ack(eventId: string): Promise<void>;
+        push(event: AgentEvent): Promise<void>;
+        pushMany?(events: readonly AgentEvent[]): Promise<void | MailboxPushManyResult>;
+        status(): Promise<{
+            pending: number;
+        }>;
+    };
+    /** 可插拔认证. proxy 持唯一凭证代调; core 只经此签请求, 不碰密钥存储. */
+    auth: AuthProvider;
+    /** 可选: hub 广告支持的能力, core 动态适配. 缺省时 core 假设全能力在线. */
+    capabilities?(): Promise<HubManifest>;
+}
+/**
+ * HubCapability 接到 core 两个 seam 的工厂(adapter 不直接 new Dispatcher):
+ * - asProxyHandler: 包成 Dispatcher.handlers.proxy(e: Envelope)=>Promise<unknown>, 按 e.type
+ *   路由到 publish / task 子系统 / mailbox.push; 抛错触发 store.fail() 重试.
+ * - asAssetTransport: 包成 assetstore RemoteTransport(put/get/search/list), 落库前 core normalizeForPut.
+ */
+export interface HubBindings {
+    asProxyHandler(): (e: Envelope) => Promise<unknown>;
+    asAssetTransport(): {
+        putRemote(record: AssetRecord): Promise<{
+            stored: boolean;
+        }>;
+        getRemote(assetId: string): Promise<AssetRecord | null>;
+        searchRemote(query: HubQuery): Promise<AssetRecord[]>;
+        listRemote(kind: AssetKind | undefined, limit: number): Promise<AssetRecord[]>;
+    };
+}
+export type { AssetRecord, AssetKind, SearchQuery, PutResult, Envelope };

package/dist/hub/capability.js

@@ -0,0 +1 @@
+export {};

package/dist/hub/conversationDistiller.d.ts

@@ -0,0 +1,88 @@
+import type { AssetRecord, AssetStoreProvider } from '../assetstore/provider.js';
+export interface ConversationDistillInput {
+    title?: unknown;
+    name?: unknown;
+    summary?: unknown;
+    user_prompt?: unknown;
+    userPrompt?: unknown;
+    assistant_summary?: unknown;
+    assistantSummary?: unknown;
+    transcript?: unknown;
+    conversation?: unknown;
+    signals?: unknown;
+    strategy?: unknown;
+    steps?: unknown;
+    artifacts?: unknown;
+    outputs?: unknown;
+    files?: unknown;
+    validation?: unknown;
+    verification?: unknown;
+    execution?: unknown;
+    blast_radius?: unknown;
+    platform?: unknown;
+    host?: unknown;
+    model?: unknown;
+    thread_id?: unknown;
+    threadId?: unknown;
+    session_id?: unknown;
+    sessionId?: unknown;
+    min_score?: unknown;
+    minScore?: unknown;
+    persist?: unknown;
+    [k: string]: unknown;
+}
+interface NormalizedExecution {
+    status: 'success' | 'failed';
+    trace: Array<{
+        command: string;
+        exit: number;
+        summary?: string;
+    }>;
+    validation: string[];
+    blast_radius: {
+        files: number;
+        lines: number;
+    };
+}
+interface NormalizedConversation {
+    text: string;
+    summary: string;
+    signals: string[];
+    strategy: string[];
+    artifacts: string[];
+    execution: NormalizedExecution;
+    platform: string;
+    model: string;
+    source_thread: string;
+}
+export interface QualityGate {
+    ok: boolean;
+    score: number;
+    threshold: number;
+    reasons: string[];
+    reason?: string;
+}
+export interface ConversationDistillOptions {
+    persist?: boolean;
+    store?: AssetStoreProvider;
+}
+export type ConversationDistillResult = {
+    ok: false;
+    status: 'skipped';
+    reason: string;
+    quality?: QualityGate;
+    signals?: string[];
+} | {
+    ok: true;
+    status: 'stored' | 'draft';
+    distill_id: string;
+    quality: QualityGate;
+    signals: string[];
+    gene: AssetRecord;
+    capsule: AssetRecord;
+};
+export declare function inferSignals(text: string, providedSignals?: unknown): string[];
+export declare function evaluateGate(input: ConversationDistillInput, normalized: NormalizedConversation): QualityGate;
+export declare function normalizeConversationInput(input: ConversationDistillInput): NormalizedConversation;
+export declare function distillConversation(input: ConversationDistillInput, opts?: ConversationDistillOptions): Promise<ConversationDistillResult>;
+export {};

package/dist/hub/conversationDistiller.js

@@ -0,0 +1,264 @@
+import { createHash } from 'node:crypto';
+import { redactString } from './sanitize.js';
+import { SCHEMA_VERSION, computeAssetId } from '../wire/index.js';
+const DEFAULT_SIGNALS = [
+    'conversation_distillation',
+    'reusable_capability',
+    'agent_self_evolution',
+];
+const SIGNAL_RULES = [
+    { signal: 'conversation_distillation', re: /\b(distill|distillation|distilled|蒸馏|提炼|萃取)\b/i },
+    { signal: 'gene_publish', re: /\b(gene|capsule|evomap|evolver|gep)\b|基因|胶囊/i },
+    { signal: 'reusable_capability', re: /\b(reusable|repeatable|workflow|playbook|capability)\b|可复用|复用|能力|流程/i },
+    { signal: 'visual_annotation', re: /\b(screenshot|annotat|mock|wireframe|playwright|visual)\b|截图|圈圈|标注|画图|飞书/i },
+    { signal: 'frontend_polish', re: /\b(frontend|ui|ux|interaction|polish|mockup)\b|前端|交互|打磨|体验/i },
+    { signal: 'proxy_sync', re: /\b(proxy|sync|mailbox|outbound|hub|asset_submit)\b|同步|队列|代理/i },
+    { signal: 'plugin_integration', re: /\b(plugin|codex|claude|cursor|antigravity|workbuddy|hook|notify)\b|插件|钩子/i },
+    { signal: 'test_verified', re: /\b(test|build|verify|passed|green)\b|测试|验证|通过/i },
+];
+function asRecord(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+function trimText(value, max) {
+    const text = redactString(String(value ?? '').replace(/\s+/g, ' ').trim());
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function asArray(value) {
+    if (value === undefined || value === null || value === '')
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function normalizeList(value, maxItems, maxLen) {
+    return asArray(value).map((item) => trimText(item, maxLen)).filter(Boolean).slice(0, maxItems);
+}
+function slugify(value) {
+    const raw = String(value || 'conversation-capability').toLowerCase();
+    const ascii = raw.replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').replace(/-{2,}/g, '-');
+    if (ascii.length >= 8)
+        return ascii.slice(0, 56).replace(/-+$/g, '');
+    const hash = createHash('sha1').update(raw, 'utf8').digest('hex').slice(0, 8);
+    return `conversation-capability-${hash}`;
+}
+function hashInput(input) {
+    return createHash('sha1').update(JSON.stringify(input ?? {}), 'utf8').digest('hex').slice(0, 10);
+}
+export function inferSignals(text, providedSignals) {
+    const found = new Set(normalizeList(providedSignals, 12, 64));
+    for (const rule of SIGNAL_RULES)
+        if (rule.re.test(text))
+            found.add(rule.signal);
+    if (found.size === 0)
+        for (const signal of DEFAULT_SIGNALS)
+            found.add(signal);
+    return [...found].slice(0, 12);
+}
+function inferCategory(signals, text) {
+    const hay = `${signals.join(' ')} ${text}`.toLowerCase();
+    if (/proxy|sync|auth|error|failure|bug|repair|修复|故障/.test(hay))
+        return 'repair';
+    if (/new|plugin|integration|feature|capability|能力|新增/.test(hay))
+        return 'innovate';
+    return 'optimize';
+}
+function normalizeBlastRadius(value) {
+    const r = asRecord(value);
+    return {
+        files: Number.isFinite(Number(r['files'])) ? Number(r['files']) : 0,
+        lines: Number.isFinite(Number(r['lines'])) ? Number(r['lines']) : 0,
+    };
+}
+function normalizePublishBlastRadius(value, artifactCount) {
+    return {
+        files: Math.max(1, Math.trunc(value.files || artifactCount || 1)),
+        lines: Math.max(1, Math.trunc(value.lines || 1)),
+    };
+}
+function capsuleContent(normalized) {
+    return redactString(JSON.stringify({
+        platform: normalized.platform,
+        source_thread: normalized.source_thread || null,
+        artifacts: normalized.artifacts,
+        excerpt: normalized.text.slice(0, 1200),
+    }));
+}
+function normalizeExecution(input) {
+    const execution = asRecord(input.execution);
+    const validation = normalizeList(input.validation ?? input.verification ?? execution['validation'], 8, 180);
+    const trace = asArray(execution['trace']).map((item) => {
+        if (typeof item === 'string')
+            return { command: trimText(item, 180), exit: 0 };
+        const row = asRecord(item);
+        if (Object.keys(row).length === 0)
+            return null;
+        return {
+            command: trimText(row['command'] ?? row['cmd'] ?? row['name'] ?? 'validation', 180),
+            exit: Number.isInteger(row['exit']) ? Number(row['exit']) : (row['ok'] === false ? 1 : 0),
+            summary: trimText(row['summary'] ?? row['output'] ?? '', 240),
+        };
+    }).filter((row) => row !== null);
+    for (const cmd of validation)
+        if (!trace.some((t) => t.command === cmd))
+            trace.push({ command: cmd, exit: 0 });
+    const ok = execution['status'] === 'success' || execution['ok'] === true || validation.length > 0 || trace.some((t) => t.exit === 0);
+    return {
+        status: ok ? 'success' : 'failed',
+        trace,
+        validation,
+        blast_radius: normalizeBlastRadius(execution['blast_radius'] ?? input.blast_radius),
+    };
+}
+function buildStrategy(input) {
+    const explicit = normalizeList(input.strategy ?? input.steps, 10, 220);
+    if (explicit.length >= 3)
+        return explicit;
+    const artifacts = normalizeList(input.artifacts ?? input.outputs ?? input.files, 6, 160);
+    const strategy = explicit.slice();
+    strategy.push('Capture the user-visible trigger and the concrete workflow that solved it.');
+    strategy.push('Preserve evidence: commands, screenshots, documents, changed files, and validation results.');
+    if (artifacts.length > 0)
+        strategy.push('Link generated artifacts back to the reusable procedure before publishing.');
+    strategy.push('Sanitize secrets and local-only paths before persisting or submitting the asset.');
+    strategy.push('Queue the resulting Gene/Capsule through the local Proxy so Hub outages do not drop the learning.');
+    return strategy.slice(0, 10);
+}
+export function evaluateGate(input, normalized) {
+    let score = 0;
+    const reasons = [];
+    if (normalized.summary.length >= 40) {
+        score += 2;
+        reasons.push('summary');
+    }
+    if (normalized.strategy.length >= 3) {
+        score += 2;
+        reasons.push('strategy');
+    }
+    if (normalized.artifacts.length > 0) {
+        score += 1;
+        reasons.push('artifacts');
+    }
+    if (normalized.execution.validation.length > 0 || normalized.execution.trace.length > 0) {
+        score += 1;
+        reasons.push('validation');
+    }
+    if (/\b(gene|capsule|distill|reusable|evomap|evolver)\b|蒸馏|提炼|可复用|基因/i.test(normalized.text)) {
+        score += 2;
+        reasons.push('explicit_distill_signal');
+    }
+    const rawThreshold = Number(input.min_score ?? input.minScore ?? 5);
+    const threshold = Number.isFinite(rawThreshold) ? rawThreshold : 5;
+    if (score < threshold)
+        return { ok: false, score, threshold, reasons, reason: 'insufficient_reusable_signal' };
+    return { ok: true, score, threshold, reasons };
+}
+export function normalizeConversationInput(input) {
+    const sourceText = [
+        input.summary,
+        input.title,
+        input.user_prompt,
+        input.userPrompt,
+        input.assistant_summary,
+        input.assistantSummary,
+        input.transcript,
+        input.conversation,
+    ].filter(Boolean).join('\n');
+    const text = trimText(sourceText, 8000);
+    const summary = trimText(input.summary ?? input.assistant_summary ?? input.assistantSummary ?? text, 300);
+    return {
+        text,
+        summary,
+        signals: inferSignals(text, input.signals),
+        strategy: buildStrategy(input),
+        artifacts: normalizeList(input.artifacts ?? input.outputs ?? input.files, 12, 240),
+        execution: normalizeExecution(input),
+        platform: trimText(input.platform ?? input.host ?? 'generic', 64),
+        model: trimText(input.model ?? '', 100) || 'unknown',
+        source_thread: trimText(input.thread_id ?? input.threadId ?? input.session_id ?? input.sessionId ?? '', 128),
+    };
+}
+export async function distillConversation(input, opts = {}) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return { ok: false, status: 'skipped', reason: 'input_object_required' };
+    const normalized = normalizeConversationInput(input);
+    if (!normalized.summary || normalized.summary.length < 20)
+        return { ok: false, status: 'skipped', reason: 'summary_required' };
+    const gate = evaluateGate(input, normalized);
+    if (!gate.ok)
+        return { ok: false, status: 'skipped', reason: gate.reason ?? 'insufficient_reusable_signal', quality: gate, signals: normalized.signals };
+    const slug = slugify(input.name ?? input.title ?? normalized.summary);
+    const fingerprint = hashInput({
+        summary: normalized.summary,
+        signals: normalized.signals,
+        strategy: normalized.strategy,
+        artifacts: normalized.artifacts,
+    });
+    const category = inferCategory(normalized.signals, normalized.text);
+    const gene = {
+        type: 'Gene',
+        schema_version: SCHEMA_VERSION,
+        id: `gene_conversation_${slug}_${fingerprint}`,
+        summary: normalized.summary,
+        category,
+        signals_match: normalized.signals,
+        preconditions: [
+            'A live agent conversation produced a repeatable workflow or capability.',
+            'The conversation includes enough evidence to reconstruct when and how to use it.',
+        ],
+        strategy: normalized.strategy,
+        validation: normalized.execution.validation.length > 0 ? normalized.execution.validation : ['node --version'],
+        constraints: { max_files: 20, forbidden_paths: ['.git', 'node_modules', '.env'] },
+        _source: {
+            kind: 'conversation_distillation',
+            platform: normalized.platform,
+            source_thread: normalized.source_thread || null,
+            quality: gate,
+            distilled_at: new Date().toISOString(),
+        },
+        asset_id: '',
+    };
+    gene.asset_id = computeAssetId(gene) ?? '';
+    const capsule = {
+        type: 'Capsule',
+        schema_version: SCHEMA_VERSION,
+        id: `capsule_conversation_${slug}_${fingerprint}`,
+        trigger: normalized.signals,
+        gene: String(gene.id),
+        summary: normalized.summary,
+        confidence: Math.min(0.95, 0.5 + gate.score / 20),
+        blast_radius: normalizePublishBlastRadius(normalized.execution.blast_radius, normalized.artifacts.length),
+        outcome: { status: normalized.execution.status, score: normalized.execution.status === 'success' ? 0.82 : 0.35 },
+        source_type: 'conversation_distillation',
+        strategy: normalized.strategy,
+        execution_trace: normalized.execution.trace,
+        a2a: { eligible_to_broadcast: true },
+        content: capsuleContent(normalized),
+        diff: '',
+        reused_asset_id: '',
+        env_fingerprint: {
+            platform: normalized.platform,
+            source_thread: normalized.source_thread || null,
+            // Underlying LLM model, threaded from the originating client via input.model (resolved by
+            // detectModelName() in the node's OWN process). We deliberately do NOT sniff the local process.env
+            // here: distillConversation also runs inside the proxy daemon (proxyDaemon relays the wire body),
+            // whose env lacks the per-session model vars — sniffing there would mis-attribute the model (#219
+            // review). Falls back to 'unknown' when the caller supplied none. Lets the Hub attribute distilled
+            // capsules by model (by-model leaderboard / anti-sybil), like the skill2gep capsule's env_fingerprint.
+            model: normalized.model,
+        },
+        asset_id: '',
+    };
+    capsule.asset_id = computeAssetId(capsule) ?? '';
+    const persist = (opts.persist ?? input.persist) === true;
+    if (persist && opts.store) {
+        await opts.store.put(gene);
+        await opts.store.put(capsule);
+    }
+    return {
+        ok: true,
+        status: persist && opts.store ? 'stored' : 'draft',
+        distill_id: fingerprint,
+        quality: gate,
+        signals: normalized.signals,
+        gene,
+        capsule,
+    };
+}

package/dist/hub/fake.d.ts

@@ -0,0 +1,45 @@
+import type { HubCapability, PublishReceipt, AgentEvent, TaskEvent, AuthProvider, HubQuery, AssetRecord } from './capability.js';
+export interface FakeHubOptions {
+    /** 脚本化 publish gate: 返回 reject/quarantine 以测 PublishReceipt 终态路径. */
+    publishGate?: (asset: AssetRecord) => Pick<PublishReceipt, 'status' | 'reason' | 'terminal'>;
+}
+/**
+ * 内存 HubCapability(M6-1, 测试用). 复用 InMemoryTransport 思路, 但走完整 HubCapability 形状,
+ * 让 SyncEngine/LifecycleManager/bindings 不连真 hub 即可端到端测.
+ */
+export declare class FakeHubCapability implements HubCapability {
+    private readonly opts;
+    private readonly assets;
+    private readonly inbox;
+    private readonly acked;
+    readonly pushed: AgentEvent[];
+    readonly claims: Array<{
+        taskId: string;
+        claimId: string;
+    }>;
+    readonly completed: Array<{
+        claimId: string;
+        result: unknown;
+    }>;
+    readonly auth: AuthProvider;
+    nextPollAfterMs: number | undefined;
+    constructor(opts?: FakeHubOptions);
+    /** 测试注入: 排一条 inbound 事件供 poll 拉. */
+    seedInbound(e: AgentEvent): void;
+    publish(bundle: AssetRecord[]): Promise<PublishReceipt>;
+    fetch(query: HubQuery): Promise<AssetRecord[]>;
+    search(query: HubQuery): Promise<AssetRecord[]>;
+    task: {
+        claim: (taskId: string) => Promise<{
+            claimId: string;
+        }>;
+        complete: (claimId: string, result: unknown) => Promise<{
+            status: "completed";
+        }>;
+        subscribe: (filter: unknown) => AsyncIterable<TaskEvent>;
+    };
+    mailbox: HubCapability['mailbox'];
+    /** 测试断言用. */
+    isAcked(id: string): boolean;
+    publishedCount(): number;
+}