@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/shared/interfaces/database.negotiation.d.ts

@@ -1,329 +0,0 @@
-/**
- * Negotiation-specific persistence: continuation receipts, private
- * consultations, and the queries the negotiation graph depends on.
- */
-import type { NegotiationOpportunityLifecycle, OpportunityStatus } from './database.entities.js';
-import type { Database } from './database.port.js';
-/**
- * Negotiation-specific query operations not covered by generic
- * conversation/task primitives.
- */
-/** A user's ordinary follow-up answer stored on established shared opportunity metadata. */
-export interface NegotiationUserAnswer {
-    questionId: string;
-    selectedOptions: string[];
-    freeText?: string;
-    answeredAt: string;
-}
-export interface NegotiationPrivateConsultation {
-    recipientUserId: string;
-    recipientIntentId: string;
-    kind: 'answer' | 'dismiss' | 'timeout';
-    selectedOptions: string[];
-    freeText?: string;
-}
-export interface NegotiationContinuationExecution {
-    taskId: string;
-    settlementId: string;
-    opportunityId: string;
-    userId: string;
-    recipientIntentId: string;
-    networkId: string;
-    intentFingerprint: string;
-    opportunityStatus: string;
-    opportunityUpdatedAt: string;
-    counterpartyUserId: string;
-    counterpartyIntentId: string;
-    successorTaskId: string;
-    conversationId: string;
-    token: string;
-    fence: number;
-    leaseExpiresAt: string;
-    consultation: NegotiationPrivateConsultation;
-}
-export interface NegotiationContinuationReceipt {
-    priorTaskId: string;
-    settlementId: string;
-    successorTaskId: string;
-    fence: number;
-    outcome: 'accepted' | 'rejected' | 'stalled' | 'waiting_for_agent' | 'input_required';
-}
-export interface NegotiationQueries {
-    /** Capture canonical material binding before arming an ask-user timeout. */
-    captureNegotiationAskUserBinding(input: {
-        taskId: string;
-        turnContext: Record<string, unknown>;
-        settlementId: string;
-        recipientUserId: string;
-        recipientIntentId: string;
-        opportunityId: string;
-        networkId: string;
-        continuationExecution?: NegotiationContinuationExecution;
-    }): Promise<{
-        version: 2;
-        settlementId: string;
-        recipientUserId: string;
-        recipientIntentId: string;
-        opportunityId: string;
-        networkId: string;
-        intentFingerprint: string;
-        opportunityStatus: string;
-        opportunityUpdatedAt: string;
-        counterpartyUserId: string;
-        counterpartyIntentId: string;
-    }>;
-    /**
-     * Persists the full negotiation turn context (source/candidate user contexts,
-     * seed assessment, index context, discovery query) onto the task metadata so
-     * that polling agents can reconstruct the same context the system agent sees
-     * in-process. Merges into `metadata.turnContext`, leaving other keys intact.
-     * @param taskId - Task whose metadata to enrich
-     * @param turnContext - Absolute (source/candidate) view of the negotiation context
-     */
-    setTaskTurnContext(taskId: string, turnContext: Record<string, unknown>, continuationExecution?: NegotiationContinuationExecution): Promise<void>;
-    /**
-     * Merges a screen-gate decision (P2.1 shadow mode) into
-     * `metadata.screenDecision`, leaving other metadata keys intact. Optional so
-     * existing fakes/wireups remain valid; when absent the screen node logs the
-     * decision and proceeds without persisting.
-     * @param taskId - Task whose metadata to enrich
-     * @param screenDecision - ScreenDecisionRecord (decision, evidence, mode, timing)
-     */
-    setTaskScreenDecision?(taskId: string, screenDecision: Record<string, unknown>, continuationExecution?: NegotiationContinuationExecution): Promise<void>;
-    /**
-     * Merges an applied deadlock→bargaining shift record (IND-428) into
-     * `metadata.deadlockShift`, leaving other metadata keys intact. Internal
-     * analytics only — API surfaces must never project this key. Optional so
-     * existing fakes/wireups remain valid; when absent the turn node logs the
-     * shift and proceeds without persisting.
-     * @param taskId - Task whose metadata to enrich
-     * @param deadlockShift - DeadlockShiftRecord (run length, threshold, turn, seat, timing)
-     */
-    setTaskDeadlockShift?(taskId: string, deadlockShift: Record<string, unknown>, continuationExecution?: NegotiationContinuationExecution): Promise<void>;
-    /**
-     * Returns the most-recently-created task whose metadata carries
-     * `type: 'negotiation'` and `opportunityId: <id>`. Returns null if no
-     * negotiation has been started for that opportunity yet.
-     */
-    getNegotiationTaskForOpportunity(opportunityId: string): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-        metadata: Record<string, unknown> | null;
-        createdAt: Date;
-        updatedAt: Date;
-    } | null>;
-    /**
-     * Returns the most-recently-created task whose metadata carries
-     * `type: 'negotiation'` on the given conversation, regardless of
-     * opportunityId or direction. Used by the init node's conversation-scoped
-     * tie-break: symmetric concurrent starts carry different opportunityIds, so
-     * the opportunity-scoped lookup above cannot see the competing task.
-     * Optional so existing fakes/wireups remain valid; when absent the
-     * tie-break is skipped (pre-stamp behavior).
-     */
-    getLatestNegotiationTaskForConversation?(conversationId: string): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-        metadata: Record<string, unknown> | null;
-        createdAt: Date;
-        updatedAt: Date;
-    } | null>;
-    /**
-     * Returns user answers collected by the questioner system for a given
-     * opportunity. Reads `metadata.userAnswers` from the opportunities table.
-     * Used by the negotiation graph to inject between-session context into
-     * continuation prompts.
-     */
-    getOpportunityUserAnswers(opportunityId: string): Promise<NegotiationUserAnswer[]>;
-}
-/**
- * Database dependency for the negotiation graph (A2A conversation/task/artifact
- * persistence). Composes generic conversation ops with negotiation-specific queries.
- *
- * Access layer: ConversationDatabaseAdapter
- */
-export type NegotiationGraphDatabase = Pick<Database, 'getOrCreateDM' | 'getUserContext'> & NegotiationQueries & {
-    /**
-     * Update the status of an opportunity. Called from the negotiation graph to
-     * advance the opportunity lifecycle (negotiating -> pending/rejected/stalled).
-     * Returns only the narrow { id, status } needed by the graph, not the full Opportunity.
-     */
-    updateOpportunityStatus(id: string, status: OpportunityStatus, acceptedBy?: string, continuationExecution?: NegotiationContinuationExecution): Promise<{
-        id: string;
-        status: OpportunityStatus;
-    } | null>;
-    /** Persists a negotiation turn message within a conversation. */
-    createMessage(data: {
-        conversationId: string;
-        senderId: string;
-        role: 'user' | 'agent';
-        parts: unknown[];
-        taskId?: string;
-        metadata?: Record<string, unknown> | null;
-        continuationExecution?: NegotiationContinuationExecution;
-    }): Promise<{
-        id: string;
-        senderId: string;
-        role: 'user' | 'agent';
-        parts: unknown;
-        createdAt: Date;
-    }>;
-    /**
-     * Atomically claims an exact persisted opportunity attempt, promotes it to
-     * negotiating, and creates its task. Returns null when the status/version is
-     * stale or another qualifying task already owns the attempt.
-     */
-    createNegotiationTaskForAttempt(input: {
-        conversationId: string;
-        opportunityId: string;
-        expectedStatus: OpportunityStatus;
-        expectedUpdatedAt: Date;
-        metadata: Record<string, unknown>;
-    }): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-    } | null>;
-    /** Creates a generic task to track a non-attempt-bound lifecycle. */
-    createTask(conversationId: string, metadata?: Record<string, unknown>): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-    }>;
-    /**
-     * Under a deterministic settlement lock, validate the exact canceled ask_user
-     * task and return its existing successor or create one. Never consults a
-     * latest-task lookup.
-     */
-    getOrCreateNegotiationContinuationTask(input: {
-        priorTaskId: string;
-        settlementId: string;
-        conversationId: string;
-        opportunityId: string;
-        metadata: Record<string, unknown>;
-    }): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-        created: boolean;
-    } | null>;
-    /** Transitions a task to a new state (e.g. working, completed, failed). */
-    updateTaskState(taskId: string, state: string, statusMessage?: unknown, continuationExecution?: NegotiationContinuationExecution, parkGeneration?: string): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-    }>;
-    /** Persists a negotiation outcome artifact attached to a task. */
-    createArtifact(data: {
-        taskId: string;
-        name?: string;
-        parts: unknown[];
-        metadata?: Record<string, unknown> | null;
-        continuationExecution?: NegotiationContinuationExecution;
-    }): Promise<{
-        id: string;
-    }>;
-    /** Lists negotiation tasks where the given user is source or candidate. */
-    getTasksForUser(userId: string, options?: {
-        state?: string;
-    }): Promise<Array<{
-        id: string;
-        conversationId: string;
-        state: string;
-        metadata: Record<string, unknown> | null;
-        createdAt: Date;
-        updatedAt: Date;
-    }>>;
-    /**
-     * Resolves each opportunity to the intent carried by the given user's actor.
-     * Missing opportunities or actor intents are returned as null so callers can
-     * enforce fail-closed scope filtering for legacy task metadata.
-     */
-    getIntentIdsForOpportunities(opportunityIds: string[], userId: string): Promise<Record<string, string | null>>;
-    /**
-     * Batch-loads current opportunity lifecycle evidence for negotiation
-     * narration. Implementations must omit opportunities that do not contain the
-     * authenticated owner actor. Optional for backward-compatible hosts; callers
-     * must treat a missing implementation as unavailable evidence, never as acceptance.
-     */
-    getOpportunityLifecyclesForNegotiations?(opportunityIds: string[], ownerUserId: string): Promise<Record<string, NegotiationOpportunityLifecycle>>;
-    /** Gets a specific task by ID. */
-    getTask(taskId: string): Promise<{
-        id: string;
-        conversationId: string;
-        state: string;
-        metadata: Record<string, unknown> | null;
-        createdAt: Date;
-        updatedAt: Date;
-    } | null>;
-    /**
-     * Gets all messages for a conversation, ordered by creation time.
-     *
-     * `taskId` is the originating negotiation task (IND-569). Optional so legacy
-     * hosts remain valid; when omitted, prior negotiation turns cannot be
-     * attributed to their opportunity and degrade to the unattributed
-     * prior-dialogue block rather than being mixed into the current opportunity.
-     */
-    getMessagesForConversation(conversationId: string): Promise<Array<{
-        id: string;
-        senderId: string;
-        role: 'user' | 'agent';
-        parts: unknown[];
-        createdAt: Date;
-        taskId?: string | null;
-    }>>;
-    /**
-     * Gets the messages belonging to ONE negotiation — those written by tasks
-     * carrying `type: 'negotiation'` and the given `opportunityId` — ordered by
-     * creation time.
-     *
-     * A negotiation is keyed by opportunity, not by task: an `ask_user` pause
-     * parks its task and resumes into a pre-claimed successor, so one negotiation
-     * spans several tasks. This is the read behind every question ABOUT a
-     * negotiation (whose turn it is, whether it has opened, how many turns it has
-     * run). `getMessagesForConversation` remains the read for conversation-wide
-     * CONTEXT — prior matches between the same pair — which must never determine
-     * a negotiation's own state.
-     *
-     * Messages with no `taskId`, or whose task carries no opportunityId, are not
-     * part of any negotiation and are never returned here.
-     */
-    getNegotiationMessages(opportunityId: string): Promise<Array<{
-        id: string;
-        senderId: string;
-        role: 'user' | 'agent';
-        parts: unknown[];
-        createdAt: Date;
-        taskId?: string | null;
-    }>>;
-    /** Gets artifacts for a task (e.g. negotiation outcome). */
-    getArtifactsForTask(taskId: string): Promise<Array<{
-        id: string;
-        name: string | null;
-        parts: unknown[];
-        metadata: Record<string, unknown> | null;
-    }>>;
-};
-/**
- * Database interface for opportunity controller (API).
- *
- * Access layer: Both UserDatabase + SystemDatabase (API handles auth)
- */
-/**
- * Optional atomic outbox for Lens B outcome capture (IND-434). Passed to a
- * winning owner-action transition so the append-only outcome event is written
- * in the SAME transaction as the status change:
- *   - a rolled-back action leaves NO event;
- *   - a committed eligible action produces EXACTLY one event;
- *   - `result.inserted` is set to true by the adapter only when a NEW row was
- *     written (idempotent retries / duplicates set it false), so the caller can
- *     gate post-commit mining on a genuine first insert.
- *
- * `event` is typed `unknown` (the api-side outcome-event insert row, cast by the
- * adapter) to keep the protocol layer free of database-schema imports. The
- * actor-resolution mode is a transaction-time precondition: selected-intent
- * captures require that exact actor intent, while unscoped captures require the
- * recipient to still have one unambiguous actor-intent scope.
- */

package/dist/shared/interfaces/database.negotiation.js

@@ -1,26 +0,0 @@
-/**
- * Negotiation-specific persistence: continuation receipts, private
- * consultations, and the queries the negotiation graph depends on.
- */
-export {};
-/**
- * Database interface for opportunity controller (API).
- *
- * Access layer: Both UserDatabase + SystemDatabase (API handles auth)
- */
-/**
- * Optional atomic outbox for Lens B outcome capture (IND-434). Passed to a
- * winning owner-action transition so the append-only outcome event is written
- * in the SAME transaction as the status change:
- *   - a rolled-back action leaves NO event;
- *   - a committed eligible action produces EXACTLY one event;
- *   - `result.inserted` is set to true by the adapter only when a NEW row was
- *     written (idempotent retries / duplicates set it false), so the caller can
- *     gate post-commit mining on a genuine first insert.
- *
- * `event` is typed `unknown` (the api-side outcome-event insert row, cast by the
- * adapter) to keep the protocol layer free of database-schema imports. The
- * actor-resolution mode is a transaction-time precondition: selected-intent
- * captures require that exact actor intent, while unscoped captures require the
- * recipient to still have one unambiguous actor-intent scope.
- */

package/dist/shared/interfaces/database.network-queries.js

@@ -1,4 +0,0 @@
-/**
- * Database operations for intent-network assignment and index ownership.
- */
-export {};

package/dist/shared/interfaces/database.opportunity-queries.js

@@ -1,4 +0,0 @@
-/**
- * Database operations for HyDE documents and the opportunity lifecycle.
- */
-export {};

package/dist/shared/interfaces/delivery-ledger.interface.d.ts

@@ -1,40 +0,0 @@
-/**
- * Delivery ledger interface for committing opportunity delivery rows.
- * Implementations live in src/adapters (e.g. database adapter).
- */
-/** A committed delivery-ledger row, as read back for digest dedup. */
-export interface DeliveredOpportunityRow {
-    opportunityId: string;
-    /** Opportunity status at the time the delivery was committed. */
-    deliveredAtStatus: string;
-    deliveredAt: Date;
-}
-export interface DeliveryLedger {
-    /**
-     * Write a committed delivery row for an opportunity.
-     * Returns 'confirmed' on first delivery, 'already_delivered' if previously committed.
-     *
-     * @param trigger - Which dispatch path produced this delivery: 'ambient' for
-     *                  real-time critical alerts (≤3/day target), 'digest' for the
-     *                  daily sweep of everything ambient passed on, 'accepted' for
-     *                  accepted-opportunity notifications to the counterparty.
-     */
-    confirmOpportunityDelivery(params: {
-        opportunityId: string;
-        userId: string;
-        agentId: string | null;
-        trigger: 'ambient' | 'digest' | 'accepted';
-    }): Promise<'confirmed' | 'already_delivered'>;
-    /**
-     * Read committed delivery rows for the given opportunities delivered to the user.
-     * Used by digest mode of `list_opportunities` to suppress opportunities the user
-     * has already been shown across days, and to select cooldown re-show candidates.
-     *
-     * Optional: hosts that predate digest dedup may not implement it; callers must
-     * degrade gracefully (no suppression) when absent.
-     */
-    getDeliveredOpportunities?(params: {
-        userId: string;
-        opportunityIds: string[];
-    }): Promise<DeliveredOpportunityRow[]>;
-}

package/dist/shared/interfaces/delivery-ledger.interface.js

@@ -1,5 +0,0 @@
-/**
- * Delivery ledger interface for committing opportunity delivery rows.
- * Implementations live in src/adapters (e.g. database adapter).
- */
-export {};

package/dist/shared/interfaces/embedder.interface.d.ts

@@ -1,92 +0,0 @@
-export type { Lens, HydeTargetCorpus } from '../../discovery/lens.inferrer.js';
-/** A single lens embedding ready for search. */
-export interface LensEmbedding {
-    /** Free-text lens label (e.g. "crypto infrastructure VC"). */
-    lens: string;
-    /** Which corpus to search. */
-    corpus: 'profiles' | 'intents' | 'premises';
-    /** 2000-dim embedding vector. */
-    embedding: number[];
-}
-/** Options for searchWithHydeEmbeddings (network scope, limits, min score). */
-export interface HydeSearchOptions {
-    /** Network IDs to scope the search (members / assigned intents only). */
-    indexScope: string[];
-    /** Exclude this user ID from results (e.g. source intent owner). */
-    excludeUserId?: string;
-    /** Max results per lens before merge (default 10). */
-    limitPerStrategy?: number;
-    /** Max results after merge/rank (default 20). */
-    limit?: number;
-    /** Minimum cosine similarity for intent searches (default 0.40). */
-    minScore?: number;
-    /**
-     * Discovery corpus gating, composed by the caller (defaults preserve legacy behavior).
-     * Omitted fields default to: intents true, profile true, profileCorpus 'premise'.
-     */
-    corpusGating?: {
-        /** Search the intents corpus. */
-        intents?: boolean;
-        /** Search the active profile corpus. */
-        profile?: boolean;
-        /** Which corpus backs 'profiles' lens hints and profile searches. */
-        profileCorpus?: 'premise' | 'user_context';
-    };
-}
-/** A single candidate from HyDE search (intent, premise, or user_context), with score and which lens matched. */
-export interface HydeCandidate {
-    type: 'intent' | 'premise' | 'user_context';
-    id: string;
-    userId: string;
-    score: number;
-    /** Free-text lens label that produced this match. */
-    matchedVia: string;
-    networkId: string;
-    /** Candidate document text (populated for user_context matches; used as candidatePayload). */
-    text?: string;
-    /** Set after merge when user matched via multiple lenses. */
-    matchedLenses?: string[];
-}
-export interface EmbeddingGenerateOptions {
-    signal?: AbortSignal;
-}
-export interface EmbeddingGenerator {
-    generate(text: string | string[], dimensions?: number, options?: EmbeddingGenerateOptions): Promise<number[] | number[][]>;
-}
-export interface VectorSearchResult<T> {
-    item: T;
-    score: number;
-}
-export type VectorStoreOption<T> = {
-    limit?: number;
-    filter?: Record<string, any>;
-    candidates?: (T & {
-        embedding?: number[] | null;
-    })[];
-    minScore?: number;
-};
-export interface VectorStore {
-    /**
-     * Search for similar items in the vector store.
-     *
-     * @param queryVector - The embedding vector to search for
-     * @param collection - The logical name of the collection (e.g., 'profiles', 'intents')
-     * @param options - generic options including limit, filter, and candidates
-     */
-    search<T>(queryVector: number[], collection: string, options?: VectorStoreOption<T>): Promise<VectorSearchResult<T>[]>;
-}
-/**
- * Embedder: generate embeddings and run vector / HyDE search.
- * Implementations: OpenAI/OpenRouter for generate, pgvector for search.
- */
-export interface Embedder extends EmbeddingGenerator, VectorStore {
-    /**
-     * Multi-lens HyDE search: run one vector search per lens embedding,
-     * then merge, deduplicate by userId, and rank (boost for multiple lens matches).
-     *
-     * @param lensEmbeddings - Array of lens embeddings to search with
-     * @param options - indexScope, excludeUserId, limits, minScore
-     * @returns Deduplicated, ranked candidates (intent or premise) with scores
-     */
-    searchWithHydeEmbeddings(lensEmbeddings: LensEmbedding[], options: HydeSearchOptions): Promise<HydeCandidate[]>;
-}

package/dist/shared/interfaces/embedder.interface.js

@@ -1,4 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════════
-// HyDE (Hypothetical Document Embeddings) search types
-// ═══════════════════════════════════════════════════════════════════════════════
-export {};

package/dist/shared/interfaces/enrichment-run.interface.d.ts

@@ -1,62 +0,0 @@
-import type { ToolRequestContext } from "./tool-request-context.interface.js";
-export type EnrichmentRunStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
-export type EnrichmentRunOperation = "preview_user_context" | "update_user_context" | "preview_user_profile" | "update_user_profile";
-export interface PreviewUserEnrichmentRunInput {
-    name?: string;
-    location?: string;
-    bioOrDescription?: string;
-    linkedinUrl?: string;
-    githubUrl?: string;
-    twitterUrl?: string;
-    websites?: string[];
-}
-export interface UpdateUserEnrichmentRunInput {
-    profileId?: string;
-    action?: string;
-    details?: string;
-    socials?: Record<string, string>;
-}
-export type EnrichmentRunInput = PreviewUserEnrichmentRunInput | UpdateUserEnrichmentRunInput;
-export interface EnrichmentRunRecord {
-    id: string;
-    userId: string;
-    agentId?: string | null;
-    operation: EnrichmentRunOperation;
-    status: EnrichmentRunStatus;
-    input: EnrichmentRunInput;
-    context: Pick<ToolRequestContext, "userId" | "userName" | "userEmail" | "scopeType" | "scopeId" | "indexName" | "sessionId" | "agentId">;
-    progress?: Record<string, unknown> | null;
-    result?: unknown;
-    error?: string | null;
-    cancelRequestedAt?: Date | null;
-    createdAt: Date;
-    startedAt?: Date | null;
-    completedAt?: Date | null;
-    expiresAt?: Date | null;
-}
-export interface CreateEnrichmentRunInput {
-    userId: string;
-    agentId?: string | null;
-    operation: EnrichmentRunOperation;
-    input: EnrichmentRunInput;
-    context: EnrichmentRunRecord["context"];
-    expiresAt?: Date;
-}
-export interface EnrichmentRunStore {
-    create(input: CreateEnrichmentRunInput): Promise<EnrichmentRunRecord>;
-    get(runId: string, userId: string): Promise<EnrichmentRunRecord | null>;
-    markRunning(runId: string): Promise<EnrichmentRunRecord | null>;
-    updateProgress(runId: string, progress: Record<string, unknown>): Promise<void>;
-    markSucceeded(runId: string, result: unknown): Promise<void>;
-    markFailed(runId: string, error: string): Promise<void>;
-    requestCancel(runId: string, userId: string): Promise<EnrichmentRunRecord | null>;
-    markCancelled(runId: string, reason?: string): Promise<void>;
-    isCancelRequested(runId: string): Promise<boolean>;
-    listActive(userId: string, limit?: number): Promise<EnrichmentRunRecord[]>;
-}
-export interface EnrichmentRunQueue {
-    enqueue(runId: string): Promise<{
-        jobId?: string | number;
-    } | void>;
-    cancel(runId: string): Promise<boolean>;
-}

package/dist/shared/interfaces/enrichment-run.interface.js

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

package/dist/shared/interfaces/enrichment.interface.js

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

package/dist/shared/interfaces/negotiation-events.interface.d.ts

@@ -1,77 +0,0 @@
-/**
- * Interfaces for negotiation yield/resume support.
- * Used by the negotiation graph and dispatcher to manage timeouts
- * for external agents that haven't responded yet.
- */
-/** Exact parked continuation generation carried by a delayed timeout job. */
-export interface NegotiationContinuationTimeoutIdentity {
-    priorTaskId: string;
-    settlementId: string;
-    successorTaskId: string;
-    token: string;
-    fence: number;
-}
-/**
- * Manages delayed timeout jobs for negotiations waiting on external agents.
- * When a negotiation yields, a timeout is enqueued. If the external agent
- * responds before the timeout, the job is cancelled.
- */
-export interface NegotiationTimeoutQueue {
-    /**
-     * Enqueue a delayed timeout job.
-     * @param negotiationId - The negotiation task ID
-     * @param turnNumber - Current turn number (used to detect stale jobs)
-     * @param delayMs - Delay in milliseconds before the timeout fires
-     * @param parkGeneration - Exact generation token persisted when this turn was parked
-     * @param continuation - Exact continuation attempt/fence when the parked task is a continuation
-     * @returns The BullMQ job ID for cancellation
-     */
-    enqueueTimeout(negotiationId: string, turnNumber: number, delayMs: number, parkGeneration: string, continuation?: NegotiationContinuationTimeoutIdentity): Promise<string>;
-    /**
-     * Cancel a pending timeout job for a negotiation.
-     * @param negotiationId - The negotiation task ID
-     */
-    cancelTimeout(negotiationId: string, parkGeneration: string): Promise<void>;
-    /**
-     * Arm the answer-window timer for an `ask_user` pause (P3.2). Fires after
-     * `delayMs` (typically 24 h); the worker resumes the negotiation with a
-     * conservative no-disclosure default when the task is still
-     * `input_required`, and no-ops otherwise (stale job).
-     *
-     * Optional so fakes and pre-P3.2 implementations stay valid; the graph only
-     * offers `ask_user` when this method is present.
-     *
-     * @param negotiationId - The paused negotiation task ID
-     * @param payload - Resume coordinates + observability context
-     * @param delayMs - Delay before the expiry fires
-     * @returns The job ID for cancellation
-     */
-    enqueueAskUserExpiry?(negotiationId: string, payload: AskUserExpiryPayload, delayMs: number): Promise<string>;
-    /**
-     * Cancel a pending ask_user answer-window timer (the client answered in
-     * time, or the negotiation reached a terminal state another way).
-     * @param negotiationId - The paused negotiation task ID
-     */
-    cancelAskUserExpiry?(negotiationId: string): Promise<void>;
-}
-/** Payload carried by an ask_user answer-window expiry job. */
-export interface AskUserExpiryPayload {
-    /** Deterministic durable settlement/outbox key for this exact paused task. */
-    settlementId: string;
-    /** Opportunity to resume via the run-existing continuation path. */
-    opportunityId: string;
-    /** The asking side's client (the user who was asked and did not answer). */
-    userId: string;
-    /** Exact owned signal consulted by the paused negotiator. */
-    recipientIntentId: string;
-    /** Exact non-personal network shared by the opportunity actors. */
-    networkId: string;
-    /** Admission-time canonical hash of the recipient intent payload/summary. */
-    intentFingerprint: string;
-    /** Admission-time opportunity lifecycle marker. */
-    opportunityStatus: string;
-    opportunityUpdatedAt: string;
-    /** Exact counterparty provenance for settlement-time eligibility checks. */
-    counterpartyUserId: string;
-    counterpartyIntentId: string;
-}

package/dist/shared/interfaces/negotiation-events.interface.js

@@ -1,6 +0,0 @@
-/**
- * Interfaces for negotiation yield/resume support.
- * Used by the negotiation graph and dispatcher to manage timeouts
- * for external agents that haven't responded yet.
- */
-export {};