> ## Documentation Index
> Fetch the complete documentation index at: https://docs.agentium.in/llms.txt
> Use this file to discover all available pages before exploring further.

# Recall and task continuity

> Bounded evidence recall, archival task summaries, resident history, and source provenance.

Bounded evidence recall, archival task summaries, resident history, and source provenance. Read the [recall and task continuity guide](/harness/continuity) for examples, defaults, and behavior.

These declarations cover every public export in this category. Import from `@agentium/harness`. Types such as `ChatMessage`, `RunContext`, and `ExecutionServices` come from [`@agentium/core`](/api-reference/core). A `?` marks an optional field.

## ContinuityContextPolicyOptions

```typescript theme={null}
export type ContinuityContextPolicyOptions = {
    id: string;
    maxRequestTokens: number;
    reservedRequestTokens: number;
};
```

## IncrementalTaskSummaryPolicyOptions

```typescript theme={null}
export type IncrementalTaskSummaryPolicyOptions = {
    id: string;
    version: number;
    modelRole: string;
    maxInputBytes: number;
    maxOutputBytes: number;
    maxTokens: number;
    maxEvidenceReferences: number;
    maxUncertainties: number;
};
```

## continuityContextPolicy

```typescript theme={null}
export declare function continuityContextPolicy(options: ContinuityContextPolicyOptions): ContextPolicy;
```

## currentSessionRecallPolicy

```typescript theme={null}
export declare function currentSessionRecallPolicy(id: string): RecallPolicy;
```

## incrementalTaskSummaryPolicy

```typescript theme={null}
export declare function incrementalTaskSummaryPolicy(options: IncrementalTaskSummaryPolicyOptions): TaskSummaryPolicy;
```

## HistoryArchive

```typescript theme={null}
/** Host-owned storage. write must acknowledge successful storage before resolving. */
export interface HistoryArchive {
    write(scope: HistoryArchiveScope, reference: HistoryArchiveReference, messages: readonly ChatMessage[]): Promise<void>;
    read(scope: HistoryArchiveScope, reference: HistoryArchiveReference): Promise<readonly ChatMessage[]>;
}
```

## HistoryArchiveReference

```typescript theme={null}
export interface HistoryArchiveReference {
    id: string;
    conversationId: string;
    messageCount: number;
    /** SHA-256 of the UTF-8 JSON message array; retrieval must match exactly. */
    digest: string;
}
```

## HistoryArchiveScope

```typescript theme={null}
export interface HistoryArchiveScope {
    identity: HarnessIdentity;
    sessionId: string;
}
```

## ResidentHistoryPolicy

```typescript theme={null}
export interface ResidentHistoryPolicy {
    /** Per-conversation limit at safe model/session boundaries, including pinned host instructions. */
    maxMessages: number;
    /** Optional per-conversation bound on UTF-8 JSON bytes. */
    maxBytes?: number;
    archive: HistoryArchive;
    /** Explicit host attestation for custom provider envelopes; default rejects unknown opaque data. */
    canEvict?: (messages: readonly ChatMessage[], provider?: ModelProvider) => boolean;
}
```

## HistoryRetentionError

```typescript theme={null}
export declare class HistoryRetentionError extends Error {
    readonly code = "history_retention_unsupported";
    constructor(message: string);
}
```

## EvidenceExcerpt

```typescript theme={null}
export type EvidenceExcerpt = {
    id: string;
    reference: EvidenceReference;
    text: string;
    completeness: "complete" | "partial";
    omissions: readonly ("source_range" | "correction_context" | "negation_context")[];
    completeGroup: boolean;
};
```

## EvidenceReference

```typescript theme={null}
export type EvidenceReference = {
    sourceId: string;
    sourceRevision: string;
    locator: string;
    archive?: HistoryArchiveReference;
    messageRange?: {
        start: number;
        end: number;
    };
};
```

## RecallBudget

```typescript theme={null}
export type RecallBudget = {
    maxQueryBytes: number;
    maxQueries: number;
    maxCandidates: number;
    maxDiscoveryBytes: number;
    maxExcerpts: number;
    maxExcerptBytes: number;
    maxSourceBytes: number;
    maxEvidenceTokens: number;
    deadlineMs: number;
    validationDeadlineMs: number;
    maxValidationBytes: number;
};
```

## RecallCandidate

```typescript theme={null}
export type RecallCandidate = {
    id: string;
    reference: EvidenceReference;
    rank: number;
};
```

## RecallDecision

```typescript theme={null}
export type RecallDecision = {
    action: "continue";
} | {
    action: "stop";
    reason: string;
} | {
    action: "await_input";
    question: string;
};
```

## RecallDiagnostic

```typescript theme={null}
export type RecallDiagnostic = {
    code: "query_limit" | "candidate_limit" | "byte_limit" | "token_limit" | "deadline" | "backend_failure" | "revision_changed" | "partial_evidence" | "invalid_response" | "pending_summary" | "unavailable_coverage" | "clarification_limit";
    phase: "open" | "discovery" | "read" | "assembly" | "summary" | "validation";
    message: string;
};
```

## RecallOperationLimits

```typescript theme={null}
export type RecallOperationLimits = {
    signal: AbortSignal;
    deadline: number;
    remainingBytes: number;
    remainingTokens: number;
};
```

## RecallPolicy

```typescript theme={null}
export interface RecallPolicy {
    id: string;
    query(input: {
        history: readonly ChatMessage[];
    }, ctx: RunContext): string | undefined;
    decide(result: RecallResult, ctx: RunContext): Promise<RecallDecision>;
}
```

## RecallReadResult

```typescript theme={null}
export type RecallReadResult = {
    status: "found";
    excerpt: EvidenceExcerpt;
    viewRevision: string;
} | {
    status: "unavailable" | "revision_changed";
    viewRevision: string;
};
```

## RecallResult

```typescript theme={null}
export type RecallResult = {
    status: "complete" | "no_accessible_evidence" | "partial" | "failed";
    excerpts: readonly EvidenceExcerpt[];
    diagnostics: readonly RecallDiagnostic[];
    viewRevision: string | null;
    usage: {
        queries: number;
        candidates: number;
        bytes: number;
        estimatedTokens: number;
        elapsedMs: number;
    };
};
```

## RecallScope

```typescript theme={null}
export type RecallScope = {
    identity: HarnessIdentity;
    sessionId: string;
    projectId?: string;
    repositoryId?: string;
};
```

## RecallSession

```typescript theme={null}
export interface RecallSession {
    readonly scope: RecallScope;
    readonly viewRevision: string;
    discover(request: {
        query: string;
        maxCandidates: number;
        maxResponseBytes: number;
    }, limits: RecallOperationLimits): Promise<{
        candidates: readonly RecallCandidate[];
        partial: boolean;
        viewRevision: string;
    }>;
    read(request: {
        reference: EvidenceReference;
        maxBytes: number;
        completeGroup?: boolean;
    }, limits: RecallOperationLimits): Promise<RecallReadResult>;
    validate(request: {
        expectedViewRevision: string;
        references: readonly EvidenceReference[];
    }, limits: RecallOperationLimits): Promise<{
        status: "valid" | "changed" | "unavailable";
        viewRevision: string;
    }>;
    close(): Promise<void>;
}
```

## RecallStore

```typescript theme={null}
export interface RecallStore {
    readonly capabilities: {
        boundedDiscovery: boolean;
        boundedReads: boolean;
        revisionValidation: boolean;
        boundedCurrentValidation: boolean /** Explicit bounded canonical-group seek attestation; required for archival summaries. */;
        canonicalArchiveReads?: boolean;
    };
    open(scope: RecallScope, limits: RecallOperationLimits): Promise<RecallSession>;
}
```

## TaskSummaryConfig

```typescript theme={null}
export type TaskSummaryConfig = {
    policy: TaskSummaryPolicy;
    maxInputBytes: number;
    maxSummaryBytes: number;
    maxSummaryTokens: number;
    maxEvidenceReferences: number;
    maxRecordBytes: number;
    maxSummaryRecords: number;
};
```

## TaskSummaryCoverage

```typescript theme={null}
export type TaskSummaryCoverage = {
    conversationId: string;
    throughArchiveOrdinal: number;
    throughArchiveId: string;
    throughArchiveDigest: string;
    throughMessage: number;
};
```

## TaskSummaryDraft

```typescript theme={null}
export type TaskSummaryDraft = {
    text: string;
    evidenceIds: readonly string[];
    uncertainties: readonly string[];
};
```

## TaskSummaryPolicy

```typescript theme={null}
export interface TaskSummaryPolicy {
    id: string;
    version: number;
    update(input: {
        previous?: TaskSummaryRecord;
        additions: readonly EvidenceExcerpt[];
    }, ctx: RunContext): Promise<TaskSummaryDraft>;
}
```

## TaskSummaryRecord

```typescript theme={null}
export type TaskSummaryRecord = {
    contractVersion: 1;
    id: string;
    revision: number;
    policyId: string;
    policyVersion: number;
    recordedAt: number;
    trust: "source";
    draft: TaskSummaryDraft;
    evidence: readonly {
        id: string;
        reference: EvidenceReference;
    }[];
    coverage: TaskSummaryCoverage;
    previousRevision?: number;
    sourceViewRevision: string;
    scope: RecallScope;
};
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.