/**
 * conversation-archive-derive-insights MCP tool.
 *
 * Chunk-anchored Phase 2 cypher emitter for conversation transcripts
 * (:ConversationArchive keyed on `conversationIdentity` — Task 397).
 *
 * Task 433: the per-chunk LLM step runs in the conversation-archive-enrich
 * skill's specialist turn. This tool no longer walks chunks or calls Haiku.
 * It accepts a single chunk's agent-produced claims, applies the durable
 * rejection sidecar filter, and emits per-kind cypher proposals for the
 * skill's per-row operator gate. Idempotency on (chunkElementId, kind,
 * contentHash) — re-runs collapse on the MERGE keys baked into mergeCypher.
 *
 * Per-row dispatch (the skill executes; this tool emits the cypher):
 *   mention                → (:Section)-[:MENTIONS {contentHash}]->(:Person|:Organization)
 *   task                   → (:Task)-[:REFERENCES {contentHash}]->(:Section)
 *                            (the skill calls mcp__plugin_work_work__work-create first,
 *                             then this REFERENCES edge via raw cypher.)
 *   preference             → MERGE (p:Preference {accountId, contentHash})
 *                            then (p)-[:OBSERVED_IN]->(chunk)
 *   note                   → MERGE (n:Note {accountId, contentHash})
 *                            then (n)-[:OBSERVED_IN]->(chunk)
 *   observed-relationship  → (:Person|:Organization)-[:RELATED_TO {contentHash, operatorConfirmed:true}]->(:Person|:Organization)
 */
export declare function rejectionsJsonlPath(accountId: string): string;
export declare function rejectionKey(chunkElementId: string, kind: string, contentHash: string): string;
export declare function loadRejections(accountId: string): Set<string>;
export declare const PROPOSAL_KINDS: readonly ["mention", "task", "preference", "note", "observed-relationship"];
export type ProposalKind = (typeof PROPOSAL_KINDS)[number];
export interface AgentClaim {
    kind: ProposalKind;
    /** ≤80 chars verbatim or near-verbatim quote the agent extracted from the chunk body. */
    evidenceSnippet: string;
    /** Display name of the primary entity. Required for mention + observed-relationship. */
    subject?: string | null;
    /** Display name of the related entity. Required for observed-relationship only. */
    object?: string | null;
    /** Kind-specific structured fields. See SKILL.md for the per-kind schema. */
    payload?: Record<string, unknown>;
}
export interface DeriveInsightsParams {
    accountId: string;
    /** elementId of the :ConversationArchive parent the operator named. */
    archiveElementId: string;
    /** elementId of the single :Section chunk the agent just read. */
    chunkElementId: string;
    /** Claims the dispatched specialist emitted in-turn from the chunk body. */
    claims: AgentClaim[];
    /** Optional override for the SDK-injected session id (provenance stamping). */
    sessionId?: string;
    /**
     * When true, count mention-claim subjects in this chunk and return those
     * reaching `inlineRewriteThreshold` in `inlineRewriteSignals`. The calling
     * skill accumulates signals across chunks; when an entity's cumulative count
     * hits threshold, resolve it via `memory-search` and dispatch the
     * `compiled-truth-rewriter` specialist.
     */
    inlineRewrite?: boolean;
    /**
     * Minimum mention-claim count for a subject to appear in
     * `inlineRewriteSignals`. Default: 2.
     */
    inlineRewriteThreshold?: number;
}
export interface Proposal {
    /** elementId of the source conversation-document :Section chunk. */
    chunkElementId: string;
    /** One of the five supported kinds. */
    kind: ProposalKind;
    /** Deterministic sha256 over kind + payload — idempotency key on re-runs. */
    contentHash: string;
    /** ≤80 chars verbatim or near-verbatim quote from the chunk. */
    evidenceSnippet: string;
    /** Human-readable description the skill surfaces to the operator. */
    proposedAction: string;
    /** Ready-to-execute cypher the skill runs on `wire` via maxy-graph-write_neo4j_cypher. */
    mergeCypher: string;
    /** Parameters for `mergeCypher`. Includes contentHash, chunkElementId, payload fields. */
    mergeParams: Record<string, unknown>;
    /**
     * Disambiguation hint for `mention` and `observed-relationship` — the operator
     * resolves these to existing :Person/:Organization elementIds via memory-search
     * before the skill executes `mergeCypher`. Null for `preference` and `task`.
     */
    disambiguation: {
        needsResolution: Array<{
            role: "subject" | "object";
            displayName: string;
            proposedLabels: Array<"Person" | "Organization">;
        }>;
    } | null;
}
export interface DeriveInsightsResult {
    archiveElementId: string;
    chunkElementId: string;
    /** Proposals the operator should triage row-by-row. */
    proposals: Proposal[];
    /** Proposals dropped because the durable rejection sidecar already records them. */
    rejectionsFiltered: number;
    /** Claims the agent emitted that did not survive normalisation (missing required fields). */
    invalidClaims: number;
    /**
     * Entities mentioned >= `inlineRewriteThreshold` times among this chunk's
     * "mention" claims. Populated only when `inlineRewrite=true`. The calling
     * skill accumulates across all chunks; when an entity's cumulative count
     * reaches threshold, resolve it via `memory-search` and dispatch the
     * `compiled-truth-rewriter` specialist. Uses display names only — no
     * elementId resolution happens here.
     */
    inlineRewriteSignals?: {
        displayName: string;
        mentionCount: number;
    }[];
}
export declare function conversationArchiveDeriveInsights(params: DeriveInsightsParams): Promise<DeriveInsightsResult>;
//# sourceMappingURL=conversation-archive-derive-insights.d.ts.map