@evomap/evolver-core 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/exec/selfPrObfuscation.d.ts

@@ -9,7 +9,8 @@ export declare function resetObfuscatedCache(reader?: ReadManifest): void;
 /**
  * Load the obfuscated-file set from the manifest. Returns a normalized Set, or null when the manifest is
  * missing / unreadable / structurally invalid (NOT an `obfuscate` array of literal string paths). null is the
- * fail-closed signal: the caller must then reject all files. Result is cached per reader.
+ * fail-closed signal: the caller must then reject all files. Success is cached per reader; failures retry briefly
+ * so startup-time transient filesystem errors do not disable self-PR until process restart.
  */
 export declare function loadObfuscatedFiles(readManifest: ReadManifest): Set<string> | null;
 /**

package/dist/exec/selfPrObfuscation.js

@@ -28,8 +28,10 @@ export function defaultReadManifest(repoRoot) {
         }
     };
 }
+const MANIFEST_TRANSIENT_RETRY_MS = 5 * 60 * 1000;
 // Resettable cache keyed by the reader identity, so distinct readers (e.g. per test) don't bleed into each other.
-// `null` = a load was attempted and FAILED (fail-closed); a Set = the loaded obfuscate paths.
+// Success is cached permanently for the reader. Failures remain fail-closed, but transient reads retry for a
+// short window before stabilizing to null for the process lifetime.
 const cache = new WeakMap();
 /** Test/maintenance hook: drop any cached load for a reader (or all readers) so the load path re-runs. */
 export function resetObfuscatedCache(reader) {
@@ -40,11 +42,15 @@ export function resetObfuscatedCache(reader) {
 /**
  * Load the obfuscated-file set from the manifest. Returns a normalized Set, or null when the manifest is
  * missing / unreadable / structurally invalid (NOT an `obfuscate` array of literal string paths). null is the
- * fail-closed signal: the caller must then reject all files. Result is cached per reader.
+ * fail-closed signal: the caller must then reject all files. Success is cached per reader; failures retry briefly
+ * so startup-time transient filesystem errors do not disable self-PR until process restart.
  */
 export function loadObfuscatedFiles(readManifest) {
-    if (cache.has(readManifest))
-        return cache.get(readManifest) ?? null;
+    const cached = cache.get(readManifest);
+    if (cached?.kind === 'loaded')
+        return cached.files;
+    if (cached?.kind === 'failed' && cached.stable)
+        return null;
     let result;
     try {
         const raw = readManifest();
@@ -63,9 +69,16 @@ export function loadObfuscatedFiles(readManifest) {
         result = new Set(manifest.obfuscate.map((f) => normalizeManifestPath(f)).filter(Boolean));
     }
     catch {
-        result = null; // fail-closed: an unreadable/invalid manifest rejects everything
+        const now = Date.now();
+        const firstFailedAt = cached?.kind === 'failed' ? cached.firstFailedAt : now;
+        cache.set(readManifest, {
+            kind: 'failed',
+            firstFailedAt,
+            stable: now - firstFailedAt >= MANIFEST_TRANSIENT_RETRY_MS,
+        });
+        return null; // fail-closed: an unreadable/invalid manifest rejects everything
     }
-    cache.set(readManifest, result);
+    cache.set(readManifest, { kind: 'loaded', files: result });
     return result;
 }
 /**

package/dist/hub/agentDirectory.d.ts

@@ -0,0 +1,90 @@
+export declare const AGENT_DIRECTORY_DEFAULT_LIMIT = 20;
+export declare const AGENT_DIRECTORY_MAX_LIMIT = 50;
+export declare const AGENT_DIRECTORY_DEFAULT_TIMEOUT_MS = 8000;
+export declare const AGENT_DIRECTORY_MAX_TIMEOUT_MS = 30000;
+export declare const AGENT_DIRECTORY_MAX_QUERY_LENGTH = 500;
+export declare const AGENT_DIRECTORY_MAX_SIGNAL_COUNT = 20;
+export declare const AGENT_DIRECTORY_MAX_SIGNAL_LENGTH = 64;
+export declare const AGENT_DIRECTORY_MAX_CURSOR_LENGTH = 256;
+export declare const AGENT_DIRECTORY_MAX_AGENT_ID_LENGTH = 128;
+export type AgentAvailability = 'online' | 'busy' | 'offline' | 'unknown';
+export type AgentDirectorySort = 'relevance' | 'reputation' | 'recent' | 'availability';
+export type SortOrder = 'asc' | 'desc';
+export interface AgentSearchRequest {
+    query?: string;
+    signals?: readonly string[];
+    availability?: AgentAvailability;
+    sort?: AgentDirectorySort;
+    order?: SortOrder;
+    cursor?: string;
+    limit?: number;
+    timeoutMs?: number;
+}
+export interface AgentTaskDiscoveryRequest {
+    title: string;
+    description?: string;
+    signals?: readonly string[];
+    availability?: AgentAvailability;
+    sort?: AgentDirectorySort;
+    order?: SortOrder;
+    cursor?: string;
+    limit?: number;
+    timeoutMs?: number;
+}
+export interface AgentDirectoryEntry {
+    agentId: string;
+    displayName?: string;
+    summary?: string;
+    capabilities?: string[];
+    domains?: string[];
+    score?: number;
+    reputation?: number;
+    completedTaskCount?: number;
+    availability?: AgentAvailability;
+    lastSeenAt?: number;
+}
+export interface AgentProfile {
+    agentId: string;
+    displayName?: string;
+    summary?: string;
+    capabilities?: string[];
+    domains?: string[];
+    reputation?: number;
+    completedTaskCount?: number;
+    availability?: AgentAvailability;
+    lastSeenAt?: number;
+}
+export interface AgentDirectoryPage {
+    items: AgentDirectoryEntry[];
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export type AgentDirectoryFailureCode = 'capability_unavailable' | 'permission_denied' | 'hub_unavailable' | 'timeout' | 'invalid_request' | 'invalid_response';
+export interface AgentDirectoryFailure {
+    code: AgentDirectoryFailureCode;
+    retryable: boolean;
+    message?: string;
+}
+export type AgentDirectoryResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: AgentDirectoryFailure;
+};
+export interface AgentDirectoryCapability {
+    search(request: AgentSearchRequest): Promise<AgentDirectoryResult<AgentDirectoryPage>>;
+    getProfile(agentId: string, options?: {
+        timeoutMs?: number;
+    }): Promise<AgentDirectoryResult<AgentProfile | null>>;
+    discoverForTask(request: AgentTaskDiscoveryRequest): Promise<AgentDirectoryResult<AgentDirectoryPage>>;
+}
+export declare class AgentDirectoryInputError extends Error {
+    readonly code = "invalid_request";
+}
+export declare function normalizeAgentSearchRequest(input: AgentSearchRequest): Required<Pick<AgentSearchRequest, 'limit' | 'timeoutMs' | 'sort' | 'order'>> & AgentSearchRequest;
+export declare function normalizeAgentTaskDiscoveryRequest(input: AgentTaskDiscoveryRequest): AgentTaskDiscoveryRequest & Required<Pick<AgentTaskDiscoveryRequest, 'limit' | 'timeoutMs' | 'sort' | 'order'>>;
+export declare function normalizeAgentId(value: string): string;
+export declare function normalizeAgentDirectoryTimeout(value: number | undefined): number;
+export declare function capabilityUnavailable(message?: string): AgentDirectoryResult<never>;
+export declare function unsupportedAgentDirectoryCapability(message?: string): AgentDirectoryCapability;

package/dist/hub/agentDirectory.js

@@ -0,0 +1,104 @@
+export const AGENT_DIRECTORY_DEFAULT_LIMIT = 20;
+export const AGENT_DIRECTORY_MAX_LIMIT = 50;
+export const AGENT_DIRECTORY_DEFAULT_TIMEOUT_MS = 8_000;
+export const AGENT_DIRECTORY_MAX_TIMEOUT_MS = 30_000;
+export const AGENT_DIRECTORY_MAX_QUERY_LENGTH = 500;
+export const AGENT_DIRECTORY_MAX_SIGNAL_COUNT = 20;
+export const AGENT_DIRECTORY_MAX_SIGNAL_LENGTH = 64;
+export const AGENT_DIRECTORY_MAX_CURSOR_LENGTH = 256;
+export const AGENT_DIRECTORY_MAX_AGENT_ID_LENGTH = 128;
+export class AgentDirectoryInputError extends Error {
+    code = 'invalid_request';
+}
+export function normalizeAgentSearchRequest(input) {
+    const query = optionalText(input.query, 'query', AGENT_DIRECTORY_MAX_QUERY_LENGTH);
+    const signals = normalizeSignals(input.signals);
+    const availability = input.availability ? enumValue(input.availability, ['online', 'busy', 'offline', 'unknown'], 'availability') : undefined;
+    if (!query && signals.length === 0)
+        throw new AgentDirectoryInputError('query_or_signals_required');
+    return {
+        ...(query ? { query } : {}),
+        ...(signals.length > 0 ? { signals } : {}),
+        ...(availability ? { availability } : {}),
+        ...(input.cursor ? { cursor: requiredText(input.cursor, 'cursor', AGENT_DIRECTORY_MAX_CURSOR_LENGTH) } : {}),
+        limit: boundedInteger(input.limit, AGENT_DIRECTORY_DEFAULT_LIMIT, 1, AGENT_DIRECTORY_MAX_LIMIT, 'limit'),
+        timeoutMs: boundedInteger(input.timeoutMs, AGENT_DIRECTORY_DEFAULT_TIMEOUT_MS, 100, AGENT_DIRECTORY_MAX_TIMEOUT_MS, 'timeout_ms'),
+        sort: input.sort ? enumValue(input.sort, ['relevance', 'reputation', 'recent', 'availability'], 'sort') : 'relevance',
+        order: input.order ? enumValue(input.order, ['asc', 'desc'], 'order') : 'desc',
+    };
+}
+export function normalizeAgentTaskDiscoveryRequest(input) {
+    const title = requiredText(input.title, 'title', AGENT_DIRECTORY_MAX_QUERY_LENGTH);
+    const description = optionalText(input.description, 'description', AGENT_DIRECTORY_MAX_QUERY_LENGTH);
+    const search = normalizeAgentSearchRequest({
+        query: [title, description].filter(Boolean).join('\n'),
+        signals: input.signals,
+        availability: input.availability,
+        sort: input.sort,
+        order: input.order,
+        cursor: input.cursor,
+        limit: input.limit,
+        timeoutMs: input.timeoutMs,
+    });
+    return { ...search, title, ...(description ? { description } : {}) };
+}
+export function normalizeAgentId(value) {
+    return requiredText(value, 'agent_id', AGENT_DIRECTORY_MAX_AGENT_ID_LENGTH);
+}
+export function normalizeAgentDirectoryTimeout(value) {
+    return boundedInteger(value, AGENT_DIRECTORY_DEFAULT_TIMEOUT_MS, 100, AGENT_DIRECTORY_MAX_TIMEOUT_MS, 'timeout_ms');
+}
+export function capabilityUnavailable(message = 'agent_directory_not_supported') {
+    return { ok: false, error: { code: 'capability_unavailable', retryable: false, message } };
+}
+export function unsupportedAgentDirectoryCapability(message) {
+    return {
+        search: async () => capabilityUnavailable(message),
+        getProfile: async () => capabilityUnavailable(message),
+        discoverForTask: async () => capabilityUnavailable(message),
+    };
+}
+function normalizeSignals(input) {
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input))
+        throw new AgentDirectoryInputError('signals_must_be_array');
+    if (input.length > AGENT_DIRECTORY_MAX_SIGNAL_COUNT)
+        throw new AgentDirectoryInputError('too_many_signals');
+    const out = [];
+    for (const value of input) {
+        if (typeof value !== 'string')
+            throw new AgentDirectoryInputError('signal_must_be_string');
+        const signal = requiredText(value, 'signal', AGENT_DIRECTORY_MAX_SIGNAL_LENGTH);
+        if (!out.includes(signal))
+            out.push(signal);
+    }
+    return out;
+}
+function optionalText(value, field, maxLength) {
+    if (value === undefined)
+        return undefined;
+    return requiredText(value, field, maxLength);
+}
+function requiredText(value, field, maxLength) {
+    if (typeof value !== 'string')
+        throw new AgentDirectoryInputError(`${field}_must_be_string`);
+    const text = value.trim();
+    if (!text)
+        throw new AgentDirectoryInputError(`${field}_required`);
+    if (text.length > maxLength)
+        throw new AgentDirectoryInputError(`${field}_too_long`);
+    return text;
+}
+function boundedInteger(value, fallback, min, max, field) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value < min || value > max)
+        throw new AgentDirectoryInputError(`${field}_out_of_range`);
+    return value;
+}
+function enumValue(value, allowed, field) {
+    if (!allowed.includes(value))
+        throw new AgentDirectoryInputError(`${field}_invalid`);
+    return value;
+}

package/dist/hub/bindings.js

@@ -19,7 +19,7 @@ function envelopeToAgentEvent(e) {
     const stableId = e.type === 'proxy_trace' && e.idempotencyKey ? e.idempotencyKey : e.id;
     return {
         id: stableId,
-        type: e.type,
+        type: e.type === 'dm_outbound' ? 'dm' : e.type,
         payload: e.payload,
         priority: 'medium',
         createdAt: e.createdAt,
@@ -59,10 +59,20 @@ export function makeHubBindings(cap, options = {}) {
                             throw new PublishRejectedError(r.status, r.terminal ?? true, r.reason);
                         return r;
                     }
-                    case 'task_claim': return cap.task.claim(String(e.payload.taskId ?? ''));
+                    case 'task_claim': {
+                        const p = e.payload;
+                        return cap.task.claim(firstString(p.taskId, p.task_id) ?? '');
+                    }
                     case 'task_complete': {
                         const p = e.payload;
-                        return cap.task.complete(String(p.claimId ?? ''), p.result);
+                        const taskId = firstString(p.taskId, p.task_id);
+                        const assetId = firstString(p.assetId, p.asset_id);
+                        const claimId = firstString(p.claimId, p.claim_id);
+                        if (!claimId) {
+                            throw new PublishRejectedError('invalid_task_complete', true, 'claim_id is required because task claim handles are opaque');
+                        }
+                        const context = taskId && assetId ? { taskId, assetId } : undefined;
+                        return cap.task.complete(claimId, p.result, context);
                     }
                     default:
                         // 其余 outbound(atp_*/heartbeat/...) 走 mailbox.push
@@ -87,4 +97,14 @@ export function makeHubBindings(cap, options = {}) {
             };
         },
     };
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value !== 'string')
+            continue;
+        const trimmed = value.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return undefined;
 }

package/dist/hub/capability.d.ts

@@ -1,5 +1,6 @@
 import type { AssetRecord, AssetKind, SearchQuery, PutResult } from '../assetstore/provider.js';
 import type { Envelope } from '../mailbox/envelope.js';
+import type { AgentDirectoryCapability } from './agentDirectory.js';
 /** publish 投递回执. hub 侧做 gate(经济/治理/RBAC 全在 hub), core 只读 status+reason. */
 export interface PublishReceipt {
     /** hub 返回的回执 id(公版=AgentEvent/decision id; 私有=审计 id). */
@@ -34,6 +35,15 @@ export interface TaskEvent {
     priority: 'high' | 'medium' | 'low';
     createdAt: number;
 }
+/**
+ * Explicit task identity needed by hubs whose completion wire does not use their
+ * adapter-specific claim handle. claimId remains opaque and must never be parsed
+ * to recover either field.
+ */
+export interface TaskCompleteContext {
+    taskId: string;
+    assetId: string;
+}
 /** Proactive Hub question that a runtime may submit for ecosystem help. */
 export interface HubQuestion {
     question: string;
@@ -153,7 +163,7 @@ export interface RecipeCapability {
     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';
+export type HubCapabilityName = 'publish' | 'fetch' | 'search' | 'task' | 'mailbox' | 'auth' | 'audit' | 'air_gap' | 'tenant_isolation' | 'marketplace' | 'economy' | 'questions' | 'recipes' | 'agent_directory';
 /** hub 能力清单(可选). core 据此动态适配 UI/行为, "按需耦合". */
 export interface HubManifest {
     capabilities: HubCapabilityName[] | string[];
@@ -232,7 +242,7 @@ export interface HubCapability {
         claim(taskId: string): Promise<{
             claimId: string;
         }>;
-        complete(claimId: string, result: unknown): Promise<{
+        complete(claimId: string, result: unknown, context?: TaskCompleteContext): Promise<{
             status: 'completed';
         }>;
         subscribe(filter: unknown): AsyncIterable<TaskEvent>;
@@ -243,6 +253,8 @@ export interface HubCapability {
     };
     /** Optional recipe/DNA seam. Recipe creation is draft-first; publishing remains explicit. */
     recipes?: RecipeCapability;
+    /** Optional agent discovery seam. Missing means the adapter does not support directory/profile discovery. */
+    agentDirectory?: AgentDirectoryCapability;
     /** mailbox 队列. poll/ack/push/status 四端点解耦(公版 /a2a/mailbox/*). */
     mailbox: {
         poll(): Promise<MailboxPollResult>;

package/dist/hub/fake.d.ts

@@ -1,4 +1,4 @@
-import type { HubCapability, PublishReceipt, AgentEvent, TaskEvent, AuthProvider, HubQuery, AssetRecord } from './capability.js';
+import type { HubCapability, PublishReceipt, AgentEvent, TaskEvent, AuthProvider, HubQuery, AssetRecord, TaskCompleteContext } from './capability.js';
 export interface FakeHubOptions {
     /** 脚本化 publish gate: 返回 reject/quarantine 以测 PublishReceipt 终态路径. */
     publishGate?: (asset: AssetRecord) => Pick<PublishReceipt, 'status' | 'reason' | 'terminal'>;
@@ -20,8 +20,10 @@ export declare class FakeHubCapability implements HubCapability {
     readonly completed: Array<{
         claimId: string;
         result: unknown;
+        context?: TaskCompleteContext;
     }>;
     readonly auth: AuthProvider;
+    agentDirectory?: import('./agentDirectory.js').AgentDirectoryCapability;
     nextPollAfterMs: number | undefined;
     constructor(opts?: FakeHubOptions);
     /** 测试注入: 排一条 inbound 事件供 poll 拉. */
@@ -33,7 +35,7 @@ export declare class FakeHubCapability implements HubCapability {
         claim: (taskId: string) => Promise<{
             claimId: string;
         }>;
-        complete: (claimId: string, result: unknown) => Promise<{
+        complete: (claimId: string, result: unknown, context?: TaskCompleteContext) => Promise<{
             status: "completed";
         }>;
         subscribe: (filter: unknown) => AsyncIterable<TaskEvent>;

package/dist/hub/fake.js

@@ -19,6 +19,7 @@ export class FakeHubCapability {
     claims = [];
     completed = [];
     auth = fakeAuth;
+    agentDirectory;
     nextPollAfterMs;
     constructor(opts = {}) {
         this.opts = opts;
@@ -42,8 +43,8 @@ export class FakeHubCapability {
             this.claims.push({ taskId, claimId });
             return { claimId };
         },
-        complete: async (claimId, result) => {
-            this.completed.push({ claimId, result });
+        complete: async (claimId, result, context) => {
+            this.completed.push({ claimId, result, ...(context ? { context } : {}) });
             return { status: 'completed' };
         },
         subscribe: async function* () {

package/dist/hub/index.d.ts

@@ -1,4 +1,5 @@
 export * from './capability.js';
+export * from './agentDirectory.js';
 export * from './fake.js';
 export * from './bindings.js';
 export * from './sanitize.js';

package/dist/hub/index.js

@@ -1,4 +1,5 @@
 export * from './capability.js';
+export * from './agentDirectory.js';
 export * from './fake.js';
 export * from './bindings.js';
 export * from './sanitize.js';

package/dist/hub/sanitize.js

@@ -16,11 +16,12 @@ const REDACT_PATTERNS = [
     /api[_-]?key[=:]\s*["']?[A-Za-z0-9-._~+/]{16,}["']?/gi,
     /secret[=:]\s*["']?[A-Za-z0-9-._~+/]{16,}["']?/gi,
     /password[=:]\s*["']?[^\s"',;)}\]]{6,}["']?/gi,
-    // GitHub tokens (ghp_, gho_, ghu_, ghs_, github_pat_)
+    // GitHub tokens (ghp_, gho_, ghu_, ghs_, ghr_, github_pat_)
     /ghp_[A-Za-z0-9]{36,}/g,
     /gho_[A-Za-z0-9]{36,}/g,
     /ghu_[A-Za-z0-9]{36,}/g,
     /ghs_[A-Za-z0-9]{36,}/g,
+    /ghr_[A-Za-z0-9]{36,}/g,
     /github_pat_[A-Za-z0-9_]{22,}/g,
     // AWS access keys
     /AKIA[0-9A-Z]{16}/g,
@@ -139,7 +140,7 @@ const LEAK_SCANNERS = [
     { type: 'api_key', pattern: /sk-proj-[A-Za-z0-9-_]{20,}/g, suggest: 'process.env.OPENAI_API_KEY' },
     { type: 'api_key', pattern: /sk-ant-[A-Za-z0-9-_]{20,}/g, suggest: 'process.env.ANTHROPIC_API_KEY' },
     { type: 'api_key', pattern: /AKIA[0-9A-Z]{16}/g, suggest: 'process.env.AWS_ACCESS_KEY_ID' },
-    { type: 'github_token', pattern: /ghp_[A-Za-z0-9]{36,}/g, suggest: 'process.env.GITHUB_TOKEN' },
+    { type: 'github_token', pattern: /gh(?:p|o|u|s|r)_[A-Za-z0-9]{36,}/g, suggest: 'process.env.GITHUB_TOKEN' },
     { type: 'github_token', pattern: /github_pat_[A-Za-z0-9_]{22,}/g, suggest: 'process.env.GITHUB_TOKEN' },
     { type: 'npm_token', pattern: /npm_[A-Za-z0-9]{36,}/g, suggest: 'process.env.NPM_TOKEN' },
     { type: 'slack_token', pattern: /xox[baprsv]-[A-Za-z0-9-]{10,}/g, suggest: 'process.env.SLACK_TOKEN' },

package/dist/index.d.ts

@@ -24,4 +24,5 @@ export * as hub from './hub/index.js';
 export * as shadow from './shadow/index.js';
 export * as ops from './ops/index.js';
 export * as util from './util/index.js';
-export * as trace from './trace/index.js';
+export * as trace from './trace/index.js';
+export * as issueReporter from './issueReporter/index.js';

package/dist/index.js

@@ -24,4 +24,5 @@ export * as hub from './hub/index.js';
 export * as shadow from './shadow/index.js';
 export * as ops from './ops/index.js';
 export * as util from './util/index.js';
-export * as trace from './trace/index.js';
+export * as trace from './trace/index.js';
+export * as issueReporter from './issueReporter/index.js';

package/dist/issueReporter/index.d.ts

@@ -0,0 +1,156 @@
+import { type EnvFingerprint } from '../bootstrap/envFingerprint.js';
+export type IssueReportSource = 'cycle_failure' | 'doctor' | 'review' | 'event';
+export type IssueDraftStatus = 'draft' | 'rejected' | 'submitted';
+export declare function isIssueReportSource(value: unknown): value is IssueReportSource;
+export interface IssueReportInput {
+    source: IssueReportSource;
+    errorClass: string;
+    cycleIds?: readonly string[];
+    eventIds?: readonly string[];
+    traceIds?: readonly string[];
+    reproductionSteps?: readonly string[];
+    diagnosticCodes?: readonly string[];
+    failureClass?: string;
+    version?: string;
+    platform?: string;
+    arch?: string;
+}
+export interface IssueDraft {
+    schemaVersion: 1;
+    fingerprint: string;
+    status: IssueDraftStatus;
+    createdAt: string;
+    updatedAt: string;
+    title: string;
+    body: string;
+    source: IssueReportSource;
+    errorClass: string;
+    cycleIds: string[];
+    eventIds: string[];
+    traceRefs: string[];
+    github?: {
+        issueNumber: number;
+        url: string;
+    };
+}
+export interface IssueReporterOptions {
+    rootDir: string;
+    workspaceScope?: string;
+    now?: () => Date;
+    env?: Record<string, string | undefined>;
+    envFingerprint?: Partial<EnvFingerprint>;
+    dedupWindowMs?: number;
+    rateLimitWindowMs?: number;
+    maxSubmissionsPerWindow?: number;
+    logger?: (entry: IssueReporterLogEntry) => void;
+}
+export interface IssueReporterLogEntry {
+    fingerprint: string;
+    status: 'draft_created' | 'duplicate' | 'rejected' | 'submitted' | 'submission_failed' | 'rate_limited';
+    errorClass?: 'approval_required' | 'rate_limited' | 'transport_error' | 'invalid_response' | 'unsafe_draft' | 'local_finalize_error' | 'quota_persistence_error';
+}
+export interface GithubIssueTransport {
+    listOpenIssues(input: {
+        repo: string;
+        page: number;
+        perPage: number;
+    }): Promise<{
+        issues: Array<{
+            number: number;
+            url: string;
+            body: string;
+            isPullRequest: boolean;
+        }>;
+        hasNextPage: boolean;
+    }>;
+    createIssue(input: {
+        repo: string;
+        title: string;
+        body: string;
+    }): Promise<{
+        number: number;
+        url: string;
+    }>;
+}
+export declare class GithubIssueTransportError extends Error {
+    readonly outcome: 'not_created' | 'ambiguous';
+    constructor(outcome: 'not_created' | 'ambiguous');
+}
+export interface SubmitIssueOptions {
+    repo: string;
+    approved: boolean;
+    approvalSource?: 'human' | 'operator_policy';
+    transport: GithubIssueTransport;
+}
+export type DraftResult = {
+    status: 'created';
+    draft: IssueDraft;
+} | {
+    status: 'duplicate';
+    draft: IssueDraft;
+};
+export type SubmitResult = {
+    status: 'submitted';
+    draft: IssueDraft;
+    errorClass?: 'local_finalize_error' | 'quota_persistence_error';
+} | {
+    status: 'already_submitted';
+    draft: IssueDraft;
+} | {
+    status: 'approval_required';
+    draft: IssueDraft;
+} | {
+    status: 'rejected';
+    draft: IssueDraft;
+} | {
+    status: 'rate_limited';
+    draft: IssueDraft;
+    errorClass?: 'issue_report_submission_in_flight' | 'issue_report_submission_ambiguous';
+} | {
+    status: 'failed';
+    draft: IssueDraft;
+    errorClass: 'transport_error' | 'invalid_response' | 'unsafe_draft' | 'local_finalize_error';
+};
+export type IssueDraftConflictErrorClass = 'issue_report_submission_in_flight' | 'issue_report_submission_ambiguous';
+export declare class IssueDraftConflictError extends Error {
+    readonly errorClass: IssueDraftConflictErrorClass;
+    constructor(errorClass: IssueDraftConflictErrorClass);
+}
+export declare function createIssueDraft(input: IssueReportInput, options: IssueReporterOptions): DraftResult;
+export declare function rejectIssueDraft(draft: IssueDraft, options: IssueReporterOptions): IssueDraft;
+export declare function submitIssueDraft(draft: IssueDraft, submit: SubmitIssueOptions, options: IssueReporterOptions): Promise<SubmitResult>;
+export type IssueDraftLookupResult = {
+    status: 'found';
+    draft: IssueDraft;
+} | {
+    status: 'missing' | 'invalid';
+};
+export declare function lookupIssueDraft(rootDir: string, fingerprint: string): IssueDraftLookupResult;
+export declare function loadIssueDraft(rootDir: string, fingerprint: string): IssueDraft | null;
+export type IssueSubmissionResolution = {
+    outcome: 'not_created' | 'abandoned';
+} | {
+    outcome: 'submitted';
+    issueNumber: number;
+    url: string;
+    repo: string;
+};
+export declare function resolveIssueSubmission(fingerprint: string, resolution: IssueSubmissionResolution, options: IssueReporterOptions): IssueDraft;
+export interface IssueReportEvent {
+    type: string;
+    eventId?: string;
+    payload?: Record<string, unknown>;
+}
+export interface IssueReportDoctorCheck {
+    name: string;
+    status: 'pass' | 'warn' | 'fail';
+}
+export interface IssueReportReviewRecord {
+    assetId: string;
+    state: 'quarantined' | 'approved' | 'rejected';
+}
+export declare function issueReportInputFromCycle(events: readonly IssueReportEvent[], cycleId: string): IssueReportInput | null;
+export declare function issueReportInputFromDoctor(checks: readonly IssueReportDoctorCheck[]): IssueReportInput | null;
+export declare function issueReportInputFromReview(record: IssueReportReviewRecord): IssueReportInput | null;
+export declare function issueReportInputFromEvent(event: IssueReportEvent): IssueReportInput | null;
+export declare function createIssueDraftForEventBestEffort(event: IssueReportEvent, options: IssueReporterOptions): DraftResult | null;