@evomap/evolver-core 2.0.0-beta.0

package/dist/hub/fake.js

@@ -0,0 +1,69 @@
+import { computeAssetId } from '../wire/index.js';
+const fakeAuth = {
+    kind: 'oauth_device_token',
+    login: async () => ({ id: 'fake-cred', kind: 'oauth_device_token', token: 'fake-token' }),
+    authenticate: async () => ({ headers: { authorization: 'Bearer fake-token' } }),
+    rotate: async () => ({ id: 'fake-cred-2', kind: 'oauth_device_token', token: 'fake-token-2' }),
+    revoke: async () => { },
+};
+/**
+ * 内存 HubCapability(M6-1, 测试用). 复用 InMemoryTransport 思路, 但走完整 HubCapability 形状,
+ * 让 SyncEngine/LifecycleManager/bindings 不连真 hub 即可端到端测.
+ */
+export class FakeHubCapability {
+    opts;
+    assets = new Map();
+    inbox = [];
+    acked = new Set();
+    pushed = [];
+    claims = [];
+    completed = [];
+    auth = fakeAuth;
+    nextPollAfterMs;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    /** 测试注入: 排一条 inbound 事件供 poll 拉. */
+    seedInbound(e) { this.inbox.push(e); }
+    async publish(bundle) {
+        const assetIds = bundle.map((a) => computeAssetId(a));
+        const gate = this.opts.publishGate?.(bundle[0] ?? {}) ?? { status: 'accepted' };
+        if (gate.status === 'accepted')
+            bundle.forEach((a, i) => this.assets.set(assetIds[i], { ...a, asset_id: assetIds[i] }));
+        return { receiptId: `rcpt-${(assetIds[0] ?? 'x').slice(7, 15)}`, status: gate.status, assetId: assetIds[0], assetIds, bundleId: `bundle-${(assetIds[0] ?? 'x').slice(7, 15)}`, ...(gate.reason ? { reason: gate.reason } : {}), ...(gate.terminal !== undefined ? { terminal: gate.terminal } : {}) };
+    }
+    async fetch(query) {
+        return [...this.assets.values()].filter((a) => !query.kind || a.type === query.kind).slice(0, query.limit ?? 1000);
+    }
+    search(query) { return this.fetch(query); }
+    task = {
+        claim: async (taskId) => {
+            const claimId = `claim-${taskId}`;
+            this.claims.push({ taskId, claimId });
+            return { claimId };
+        },
+        complete: async (claimId, result) => {
+            this.completed.push({ claimId, result });
+            return { status: 'completed' };
+        },
+        subscribe: async function* () {
+            /* 内存桩: 空流 */
+        }.bind(this),
+    };
+    mailbox = {
+        poll: async () => {
+            const events = this.inbox.splice(0);
+            return { events, ...(this.nextPollAfterMs !== undefined ? { nextPollAfterMs: this.nextPollAfterMs } : {}), hasMore: this.inbox.length > 0 };
+        },
+        ack: async (eventId) => { this.acked.add(eventId); },
+        push: async (event) => { this.pushed.push(event); },
+        pushMany: async (events) => {
+            this.pushed.push(...events);
+            return { outcomes: events.map((event) => ({ id: event.id, status: 'accepted' })) };
+        },
+        status: async () => ({ pending: this.inbox.length }),
+    };
+    /** 测试断言用. */
+    isAcked(id) { return this.acked.has(id); }
+    publishedCount() { return this.assets.size; }
+}

package/dist/hub/hubReview.d.ts

@@ -0,0 +1,91 @@
+import type { AssetCallLog } from './assetCallLog.js';
+export interface ReviewOutcome {
+    status?: string;
+    score?: number;
+}
+export interface ConstraintCheck {
+    violations?: readonly unknown[];
+}
+/** Submit a review to the hub. Resolve {ok:false,error} for a rejection; reject/throw for a transport error. */
+export type ReviewSubmitter = (assetId: string, review: {
+    sender_id?: string;
+    rating: number;
+    content: string;
+}) => Promise<{
+    ok: boolean;
+    status?: number;
+    error?: string;
+}>;
+export interface ReviewHistoryStore {
+    has(assetId: string): boolean;
+    mark(assetId: string, rec: {
+        rating: number;
+        success: boolean;
+        at: number;
+    }): void;
+}
+/** Derive a 1-5 rating from the cycle outcome. success→{5 if score≥0.85 else 4}; failure→{1 if constraint-violating else 2}. */
+export declare function deriveRating(outcome?: ReviewOutcome, constraintCheck?: ConstraintCheck): number;
+export interface ReviewContentParams {
+    outcome?: ReviewOutcome;
+    gene?: {
+        id?: string;
+        category?: string;
+    };
+    signals?: readonly string[];
+    blast?: {
+        files?: number;
+        lines?: number;
+    };
+    sourceType?: string;
+}
+/** Human-readable review body summarising the reuse outcome (capped 2000 chars). */
+export declare function buildReviewContent({ outcome, gene, signals, blast, sourceType }: ReviewContentParams): string;
+export interface SubmitHubReviewDeps {
+    submit: ReviewSubmitter;
+    history?: ReviewHistoryStore;
+    assetLog?: Pick<AssetCallLog, 'append'>;
+    senderId?: string;
+    now?: () => number;
+}
+export interface SubmitHubReviewParams {
+    reusedAssetId: string;
+    /** Only 'reused' / 'reference' are hub-sourced (others are skipped). */
+    sourceType: string;
+    outcome?: ReviewOutcome;
+    gene?: {
+        id?: string;
+        category?: string;
+    };
+    signals?: readonly string[];
+    blast?: {
+        files?: number;
+        lines?: number;
+    };
+    constraintCheck?: ConstraintCheck;
+    runId?: string | null;
+}
+export interface SubmitHubReviewResult {
+    submitted: boolean;
+    reason?: string;
+    rating?: number;
+    asset_id?: string;
+}
+/**
+ * Submit a usage-verified review for a reused hub asset. Skips when: not hub-sourced, no asset id, or already
+ * reviewed. Never throws — a transport error is logged and swallowed (solidify must not be affected).
+ */
+export declare function submitHubReview(deps: SubmitHubReviewDeps, params: SubmitHubReviewParams): Promise<SubmitHubReviewResult>;
+/** File-backed ReviewHistoryStore: a JSON map assetId → {at,rating,success}, capped to the most recent N (atomic write). */
+export declare class FileReviewHistory implements ReviewHistoryStore {
+    private readonly path;
+    private readonly max;
+    constructor(path: string, max?: number);
+    private load;
+    has(assetId: string): boolean;
+    mark(assetId: string, rec: {
+        rating: number;
+        success: boolean;
+        at: number;
+    }): void;
+}

package/dist/hub/hubReview.js

@@ -0,0 +1,106 @@
+// Hub asset review (ported from v1 gep/hubReview.js). When an evolution cycle REUSED a hub asset, this submits
+// a usage-verified review back to the hub after solidify — closing the quality-feedback loop so the hub can
+// rank assets by whether reuse actually paid off (the evolver side of fetch→outcome attribution). Rating is
+// derived from the cycle outcome: success → 4-5, failure → 1-2 (a constraint-violating reuse gets the worst
+// rating, tying into the exec policy gate). Non-blocking: errors never affect solidify. Dedup via an injected
+// history store. The hub POST is an injected ReviewSubmitter seam, so this is transport-agnostic and testable.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Derive a 1-5 rating from the cycle outcome. success→{5 if score≥0.85 else 4}; failure→{1 if constraint-violating else 2}. */
+export function deriveRating(outcome, constraintCheck) {
+    if (outcome && outcome.status === 'success') {
+        const score = Number(outcome.score) || 0;
+        return score >= 0.85 ? 5 : 4;
+    }
+    const violated = !!constraintCheck && Array.isArray(constraintCheck.violations) && constraintCheck.violations.length > 0;
+    return violated ? 1 : 2;
+}
+/** Human-readable review body summarising the reuse outcome (capped 2000 chars). */
+export function buildReviewContent({ outcome, gene, signals, blast, sourceType }) {
+    const status = outcome?.status ?? 'unknown';
+    const score = outcome && Number.isFinite(Number(outcome.score)) ? Number(outcome.score).toFixed(2) : '?';
+    const parts = [`Outcome: ${status} (score: ${score})`, `Reuse mode: ${sourceType ?? 'unknown'}`];
+    if (gene?.id)
+        parts.push(`Gene: ${gene.id} (${gene.category ?? 'unknown'})`);
+    if (Array.isArray(signals) && signals.length > 0)
+        parts.push(`Signals: ${signals.slice(0, 6).join(', ')}`);
+    if (blast)
+        parts.push(`Blast radius: ${blast.files ?? 0} file(s), ${blast.lines ?? 0} line(s)`);
+    parts.push(status === 'success'
+        ? 'The fetched asset was successfully applied and solidified.'
+        : 'The fetched asset did not lead to a successful evolution cycle.');
+    return parts.join('\n').slice(0, 2000);
+}
+/**
+ * Submit a usage-verified review for a reused hub asset. Skips when: not hub-sourced, no asset id, or already
+ * reviewed. Never throws — a transport error is logged and swallowed (solidify must not be affected).
+ */
+export async function submitHubReview(deps, params) {
+    const { reusedAssetId, sourceType, outcome, gene, signals, blast, constraintCheck, runId = null } = params;
+    const now = deps.now ?? (() => Date.now());
+    if (!reusedAssetId || typeof reusedAssetId !== 'string')
+        return { submitted: false, reason: 'no_reused_asset_id' };
+    if (sourceType !== 'reused' && sourceType !== 'reference')
+        return { submitted: false, reason: 'not_hub_sourced' };
+    if (deps.history?.has(reusedAssetId))
+        return { submitted: false, reason: 'already_reviewed' };
+    const rating = deriveRating(outcome, constraintCheck);
+    const content = buildReviewContent({ outcome, gene, signals, blast, sourceType });
+    try {
+        const res = await deps.submit(reusedAssetId, { ...(deps.senderId ? { sender_id: deps.senderId } : {}), rating, content });
+        if (res.ok) {
+            deps.history?.mark(reusedAssetId, { rating, success: true, at: now() });
+            deps.assetLog?.append({ run_id: runId, action: 'hub_review_submitted', asset_id: reusedAssetId, extra: { rating, outcome_status: outcome?.status } });
+            return { submitted: true, rating, asset_id: reusedAssetId };
+        }
+        const errCode = res.error ?? `http_${res.status ?? 0}`;
+        if (errCode === 'already_reviewed')
+            deps.history?.mark(reusedAssetId, { rating, success: false, at: now() });
+        deps.assetLog?.append({ run_id: runId, action: 'hub_review_rejected', asset_id: reusedAssetId, extra: { rating, error: errCode } });
+        return { submitted: false, reason: errCode, rating };
+    }
+    catch (err) {
+        const reason = err instanceof Error && err.name === 'AbortError' ? 'timeout' : 'fetch_error';
+        deps.assetLog?.append({ run_id: runId, action: 'hub_review_failed', asset_id: reusedAssetId, extra: { rating, reason, error: err instanceof Error ? err.message : String(err) } });
+        return { submitted: false, reason, rating };
+    }
+}
+const HISTORY_MAX = 500;
+/** File-backed ReviewHistoryStore: a JSON map assetId → {at,rating,success}, capped to the most recent N (atomic write). */
+export class FileReviewHistory {
+    path;
+    max;
+    constructor(path, max = HISTORY_MAX) {
+        this.path = path;
+        this.max = max;
+    }
+    load() {
+        try {
+            if (!existsSync(this.path))
+                return {};
+            const raw = readFileSync(this.path, 'utf8').trim();
+            return raw ? JSON.parse(raw) : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    has(assetId) { return !!this.load()[assetId]; }
+    mark(assetId, rec) {
+        try {
+            const history = this.load();
+            history[assetId] = rec;
+            const keys = Object.keys(history);
+            if (keys.length > this.max) {
+                const oldest = keys.map((k) => ({ k, t: history[k].at || 0 })).sort((a, b) => a.t - b.t).slice(0, keys.length - this.max);
+                for (const { k } of oldest)
+                    delete history[k];
+            }
+            mkdirSync(dirname(this.path), { recursive: true });
+            const tmp = `${this.path}.tmp`;
+            writeFileSync(tmp, `${JSON.stringify(history, null, 2)}\n`, 'utf8');
+            renameSync(tmp, this.path);
+        }
+        catch { /* non-fatal */ }
+    }
+}

package/dist/hub/index.d.ts

@@ -0,0 +1,10 @@
+export * from './capability.js';
+export * from './fake.js';
+export * from './bindings.js';
+export * from './sanitize.js';
+export * from './ingest.js';
+export * from './assetCallLog.js';
+export * from './hubReview.js';
+export * from './reuseDecision.js';
+export * from './conversationDistiller.js';
+export * from './questionGenerator.js';

package/dist/hub/index.js

@@ -0,0 +1,10 @@
+export * from './capability.js';
+export * from './fake.js';
+export * from './bindings.js';
+export * from './sanitize.js';
+export * from './ingest.js';
+export * from './assetCallLog.js';
+export * from './hubReview.js';
+export * from './reuseDecision.js';
+export * from './conversationDistiller.js';
+export * from './questionGenerator.js';

package/dist/hub/ingest.d.ts

@@ -0,0 +1,15 @@
+import type { HubCapability, HubQuery } from './capability.js';
+import type { AssetStoreProvider } from '../assetstore/provider.js';
+import { type ProvenanceStore } from '../assetstore/provenance.js';
+export interface HubIngestResult {
+    ingested: number;
+    assetIds: string[];
+}
+/**
+ * Fetch assets from the hub and land each into the local store as UNTRUSTED. store.put recomputes the
+ * asset_id (a remote-supplied id is never trusted) and the provenance sidecar marks each untrusted.
+ * mode 'search' uses the hub's recall strategy; 'fetch' (default) is a direct pull.
+ */
+export declare function ingestFromHub(cap: HubCapability, store: AssetStoreProvider, provenance: ProvenanceStore, query: HubQuery, opts?: {
+    mode?: 'fetch' | 'search';
+}): Promise<HubIngestResult>;

package/dist/hub/ingest.js

@@ -0,0 +1,15 @@
+import { ingestUntrusted } from '../assetstore/provenance.js';
+/**
+ * Fetch assets from the hub and land each into the local store as UNTRUSTED. store.put recomputes the
+ * asset_id (a remote-supplied id is never trusted) and the provenance sidecar marks each untrusted.
+ * mode 'search' uses the hub's recall strategy; 'fetch' (default) is a direct pull.
+ */
+export async function ingestFromHub(cap, store, provenance, query, opts = {}) {
+    const records = await (opts.mode === 'search' ? cap.search(query) : cap.fetch(query));
+    const assetIds = [];
+    for (const rec of records) {
+        const r = await ingestUntrusted(store, provenance, rec, 'hub');
+        assetIds.push(r.asset_id);
+    }
+    return { ingested: assetIds.length, assetIds };
+}

package/dist/hub/questionGenerator.d.ts

@@ -0,0 +1,59 @@
+import type { HubQuestion } from './capability.js';
+export declare const QUESTION_INTERVAL_MS: number;
+export declare const URGENT_QUESTION_INTERVAL_MS: number;
+export declare const EXPLORATION_QUESTION_INTERVAL_MS: number;
+export declare const MAX_QUESTIONS_PER_CYCLE = 3;
+export declare const MAX_URGENT_QUESTIONS = 2;
+export declare const URGENT_QUESTION_RUNTIME_WIRING_STATUS: {
+    readonly status: "deferred";
+    readonly reason: "urgent_question_runtime_wiring_not_connected";
+};
+export interface QuestionGeneratorState {
+    lastAskedAt?: string | null;
+    lastUrgentAt?: string | null;
+    lastExploreAt?: string | null;
+    recentQuestions?: readonly string[];
+}
+export interface RecentEvolutionEventLike {
+    genes_used?: readonly string[];
+    genesUsed?: readonly string[];
+}
+export interface GenerateQuestionsInput {
+    signals?: readonly string[];
+    recentEvents?: readonly RecentEvolutionEventLike[];
+    sessionTranscript?: string;
+    memorySnippet?: string;
+    state?: QuestionGeneratorState;
+    now?: number;
+    env?: Record<string, string | undefined>;
+    explorationEnabled?: boolean;
+}
+export interface GenerateUrgentQuestionsInput {
+    validationFailed?: boolean;
+    validationErrors?: string;
+    geneId?: string;
+    lowConfidence?: boolean;
+    confidenceScore?: number;
+    intent?: string;
+    llmReviewRejected?: boolean;
+    llmReviewReason?: string;
+    zeroBlastRadius?: boolean;
+    hadSignals?: boolean;
+    signals?: readonly string[];
+    taskCompletionFailed?: boolean;
+    taskTitle?: string;
+    taskSignals?: string;
+    state?: QuestionGeneratorState;
+    now?: number;
+}
+export interface GeneratedQuestion extends HubQuestion {
+    priority: number;
+}
+export interface QuestionGenerationResult {
+    questions: HubQuestion[];
+    state: QuestionGeneratorState;
+    changed: boolean;
+}
+export declare function extractTopicKeywords(transcript: string | undefined, memory: string | undefined, max?: number): string[];
+export declare function generateQuestions(input?: GenerateQuestionsInput): QuestionGenerationResult;
+export declare function generateUrgentQuestions(input?: GenerateUrgentQuestionsInput): QuestionGenerationResult;