qlogicagent 2.19.13 → 2.20.1

package/dist/types/skills/memory/local-store.d.ts

@@ -1,376 +0,0 @@
-/**
- * Local Memory Store - SQLite-backed persistence for qmemory.
- *
- * Ported from Python qmemory's memory_store.py + db.py.
- * Uses better-sqlite3 for synchronous, fast, single-file persistence.
- *
- * Storage location:
- *   ~/.qlogicagent/profiles/<owner_user_id>/memory/memories.db
- *
- * Schema:
- *   - memories: core fact storage with optional embedding blob
- *   - memories_fts: FTS5 full-text index for keyword search
- *   - profiles: user profile KV (future)
- */
-import type { MemoryAtlasResult, MemoryClaimInput, MemoryClaimRecord, MemoryClaimStatus, MemoryConflictRecord, MemoryInsertInput, MemoryObservationInput, MemoryProposalInput, MemoryProposalRecord, MemoryProposalStatus, MemoryRecord, MemorySearchHit, MemoryUpdateInput, SqliteDatabase } from "./local-store-records.js";
-export { resolveMemoryDbPath } from "./memory-db-path.js";
-export type { MemoryAtlasBucket, MemoryAtlasCluster, MemoryAtlasResult, MemoryAtlasWindowCursor, MemoryAttachmentRef, MemoryClaimInput, MemoryClaimRecord, MemoryClaimStatus, MemoryConflictRecord, MemoryInsertInput, MemoryObservationInput, MemoryObservationRecord, MemoryProposalInput, MemoryProposalRecord, MemoryProposalStatus, MemoryRecord, MemorySearchHit, MemorySourceKind, MemoryUpdateInput, SqliteDatabase, SqliteStatement, } from "./local-store-records.js";
-/** Full attachment index row (DB-backed; file bytes live on disk under the attachments dir). */
-export interface MemoryAttachmentRow {
-    id: string;
-    memoryId: string;
-    userId: string;
-    kind: string;
-    filename: string;
-    mimeType: string;
-    size: number;
-    relPath: string;
-    extractedText: string;
-    createdAt: number;
-}
-export interface MemoryAttachmentInsert {
-    id: string;
-    userId: string;
-    kind: string;
-    filename: string;
-    mimeType: string;
-    size: number;
-    relPath: string;
-    extractedText?: string;
-    memoryId?: string;
-}
-export declare class LocalMemoryStore {
-    private db;
-    /** Stamped onto rows whose embedding arrives without explicit provenance
-     * (the consolidation pipeline passes bare vectors). Set by the provider. */
-    private defaultEmbeddingModel;
-    constructor(db: SqliteDatabase);
-    setDefaultEmbeddingModel(model: string): void;
-    private initSchema;
-    /**
-     * Insert a new memory record. Returns the generated ID.
-     */
-    insert(input: MemoryInsertInput): string;
-    /**
-     * Full-text search using FTS5. Returns ranked results.
-     */
-    searchFts(query: string, userId: string, limit?: number): MemorySearchHit[];
-    /** One-shot flag: embedding provenance mismatches are traced once per store instance. */
-    private embeddingMismatchLogged;
-    /**
-     * Vector similarity search using pre-computed embeddings.
-     * Performs brute-force cosine similarity (efficient for <100k records per user).
-     *
-     * Rows whose embedding provenance (dims, and model when both sides are known)
-     * differs from the query's are SKIPPED, not scored: cosine between vectors of
-     * different models/dims is numeric noise, and truncated dot products silently
-     * corrupt ranking. Legacy rows (no provenance columns) are accepted when their
-     * dimension happens to match — dropping them all would blank historical recall.
-     */
-    searchVector(queryEmbedding: Float32Array, userId: string, limit?: number, minScore?: number, expectedModel?: string): MemorySearchHit[];
-    /**
-     * Hybrid search: FTS5 + vector similarity, fused by rank-tempered RRF.
-     *
-     * Two currencies, each carrying signal the other cannot:
-     *   - channel scores (0-1, isomorphic across FTS/vector) carry MAGNITUDE —
-     *     an exact lexical hit must beat weak-consensus noise, which pure rank
-     *     fusion cannot guarantee (rank ignores how strong a match is);
-     *   - reciprocal ranks carry CONSENSUS and are scale-invariant — as the
-     *     store grows, BM25 inflates until squashed top scores compress to
-     *     near-ties and the two channels' score distributions drift apart;
-     *     ranks keep differentiating where magnitudes saturate.
-     * fused = (1-w)*magnitude + w*rrfNorm keeps both properties. Magnitude of a
-     * dual hit is the stronger channel plus a fraction of the weaker (consensus
-     * also rewarded in score space); rrfNorm is the reciprocal-rank sum
-     * normalized so a dual #1 hit = 1.0. FTS ranks follow BM25 order, vector
-     * ranks follow the blended channel order — each channel's own relevance
-     * ordering. Rows found by FTS only (e.g. no embedding) compete in the same
-     * fused domain and remain reachable, not buried.
-     */
-    searchHybrid(query: string, queryEmbedding: Float32Array | null, userId: string, limit?: number, expectedModel?: string): MemorySearchHit[];
-    /**
-     * Get all memories for a user (paginated).
-     */
-    listByUser(userId: string, page?: number, pageSize?: number, activeOnly?: boolean): MemoryRecord[];
-    /**
-     * All active memories carrying a tag (LIKE match on the quoted JSON-array
-     * element). Tag consumers (resident refresh / onboarding replace-purge) need
-     * the COMPLETE tag set regardless of age — the windowed atlas read silently
-     * truncated them once history outgrew one page/time window. No LIMIT by
-     * design: a capped "complete" read is the same bug at a higher threshold
-     * (a purge that misses rows resurrects stale memories). Tag sets are small
-     * (one origin/resident group), and this is not a hot path.
-     */
-    listByTag(userId: string, tag: string): MemoryRecord[];
-    /**
-     * Return a windowed atlas payload for large-history visualization.
-     *
-     * `records` are only the interactive window. `buckets` and `clusters` summarize
-     * the whole history so the UI can render distant history as star dust /
-     * aggregate galaxies without loading every memory as an interactive object.
-     */
-    getAtlas(userId: string, options?: {
-        pageSize?: number;
-        windowStartAt?: number;
-        windowEndAt?: number;
-        windowCenterAt?: number;
-        bucketCount?: number;
-        clusterLimit?: number;
-        activeOnly?: boolean;
-    }): MemoryAtlasResult;
-    private getAtlasBuckets;
-    private getAtlasClusters;
-    /**
-     * Get a single memory by ID.
-     */
-    getById(id: string): MemoryRecord | null;
-    /**
-     * Update memory text and bump updatedAt.
-     */
-    updateText(id: string, text: string, embedding?: Float32Array, embeddingModel?: string): boolean;
-    /**
-     * Update editable memory fields and bump updatedAt.
-     */
-    update(id: string, input: MemoryUpdateInput): boolean;
-    /**
-     * Delete a memory by ID.
-     */
-    delete(id: string): boolean;
-    /**
-     * Archive a memory (soft-delete: set is_archived=1).
-     * Used by dedup gate when a similar but newer memory supersedes an older one.
-     */
-    archive(id: string): boolean;
-    /** V3 demote(降格)恢复:archived procedure 回归召回池,与 archive 成对。 */
-    unarchive(id: string): boolean;
-    /**
-     * Temporal expiry: archive event/plan memories whose event_date has passed
-     * beyond a grace period (e.g., "meeting tomorrow" 3 days after it happened).
-     */
-    decayTemporalExpiry(userId: string, graceDays?: number): number;
-    /**
-     * Staleness decay: reduce importance of memories not accessed in a long time.
-     * Memories accessed recently retain their importance; stale ones degrade.
-     */
-    decayStaleness(userId: string, staleDays?: number, decayFactor?: number): number;
-    /**
-     * Noise archival: archive low-importance memories that never got accessed.
-     * Memories written by the agent but never recalled are likely noise.
-     */
-    decayNoiseArchival(userId: string, minAgeDays?: number, maxImportance?: number): number;
-    /**
-     * Observation retention: memory_observations is an append-only audit trail
-     * (every propose/commit writes one) with NO reader of its own — without a
-     * retention window it grows forever, the same disease the proposals table
-     * had before the consumer existed. Delete rows older than the window that
-     * are NOT referenced by any claim's evidence_ids or proposal's
-     * observation_ids (referenced rows are live audit evidence and stay).
-     */
-    decayObservations(userId: string, retentionDays?: number): number;
-    /**
-     * Resolved-proposal retention: terminal rows (accepted/merged/rejected/
-     * expired) are processing history, not memory — past the window they only
-     * grow the table. Rows carrying an idempotency_key are KEPT FOREVER: they
-     * are the crash-safe ledger that stops feedback distillation from
-     * re-proposing the same evidence cluster (deleting them would re-open the
-     * exact duplicate-write hole the key exists to close). Pending rows are
-     * never touched here — the consumer owns their TTL (status=expired).
-     */
-    decayResolvedProposals(userId: string, retentionDays?: number): number;
-    /**
-     * Run all decay strategies. Returns total affected count.
-     */
-    runFullDecay(userId: string, options?: {
-        temporalGraceDays?: number;
-        staleDays?: number;
-        staleDecayFactor?: number;
-        noiseMinAgeDays?: number;
-        noiseMaxImportance?: number;
-    }): {
-        temporal: number;
-        stale: number;
-        noise: number;
-        total: number;
-    };
-    /**
-     * Apply feedback signal to a memory, adjusting importance accordingly.
-     *
-     * Signals:
-     *   - "useful" boosts importance by +0.15 (capped at 1.0)
-     *   - "irrelevant" reduces importance by -0.2
-     *   - "outdated" archives immediately
-     *   - "wrong" deletes immediately
-     */
-    applyFeedback(memoryId: string, signal: "useful" | "irrelevant" | "outdated" | "wrong"): boolean;
-    /**
-     * Get a profile value for a user.
-     */
-    getProfile(userId: string, key: string): string | null;
-    /**
-     * Set a profile value (upsert).
-     */
-    setProfile(userId: string, key: string, value: string): void;
-    /**
-     * Get all profile entries for a user.
-     */
-    getAllProfiles(userId: string): Record<string, string>;
-    /**
-     * Delete a profile entry.
-     */
-    deleteProfile(userId: string, key: string): boolean;
-    private profileTableCreated;
-    private ensureProfileTable;
-    /**
-     * Retrieve memories within a time range, grouped by day.
-     * Used for "what happened last week" type queries and dream synthesis.
-     */
-    getTemporalSlice(userId: string, startMs: number, endMs: number, options?: {
-        category?: string;
-        limit?: number;
-    }): Array<{
-        date: string;
-        memories: Array<{
-            id: string;
-            text: string;
-            category: string;
-            importance: number;
-        }>;
-    }>;
-    /**
-     * Get memory activity summary over recent N days.
-     * Returns daily counts and high-importance entries used by temporal synthesis.
-     */
-    getActivitySummary(userId: string, days?: number): {
-        dailyCounts: Array<{
-            date: string;
-            count: number;
-        }>;
-        highlights: Array<{
-            id: string;
-            text: string;
-            category: string;
-            importance: number;
-            date: string;
-        }>;
-    };
-    /**
-     * Record an access (for importance/relevance boosting).
-     */
-    recordAccess(id: string): void;
-    /** Total active memory rows across ALL users (health reporting). */
-    countAll(): number;
-    /**
-     * Get total memory count for a user.
-     */
-    count(userId: string, activeOnly?: boolean): number;
-    /**
-     * Delete ALL long-term memory state for a user — every table, not just
-     * `memories`. Claims carry entity/predicate/value facts in clear text and
-     * observations carry raw conversation excerpts; leaving them behind after a
-     * "clear my memory" is a broken privacy promise, not a smaller reset.
-     *
-     * Returns the attachment rel_paths so the caller can delete the on-disk
-     * files (the store only owns the index rows).
-     */
-    resetUser(userId: string): {
-        memories: number;
-        observations: number;
-        proposals: number;
-        claims: number;
-        conflicts: number;
-        profiles: number;
-        attachmentRelPaths: string[];
-    };
-    /**
-     * Run SQLite VACUUM to reclaim space after deletions/archival.
-     * Should be called periodically (e.g. after decay cycles).
-     */
-    vacuum(): void;
-    /**
-     * Get database size info for capacity monitoring.
-     */
-    getStorageStats(): {
-        pageCount: number;
-        pageSize: number;
-        totalBytes: number;
-        freePages: number;
-    };
-    /**
-     * List the oldest archived memories for cold-storage export. Read-only:
-     * purging is a SEPARATE step (purgeMemoriesByIds) the caller performs only
-     * after the export has durably landed on disk. The old fused
-     * export-then-delete shape destroyed data whenever the caller dropped the
-     * return value.
-     */
-    listArchivedForExport(userId: string, maxExport?: number): Array<{
-        id: string;
-        text: string;
-        category: string;
-        importance: number;
-        createdAt: number;
-        archivedAt: number;
-        tags: string[];
-    }>;
-    /** Physically delete memory rows by id (post-export purge step). */
-    purgeMemoriesByIds(ids: string[]): number;
-    /**
-     * Enforce capacity limit: if active memories exceed maxCount,
-     * archive the oldest lowest-importance ones.
-     */
-    enforceCapacityLimit(userId: string, maxCount?: number): number;
-    insertObservation(input: MemoryObservationInput): string;
-    insertProposal(input: MemoryProposalInput): string;
-    /**
-     * Look up an existing proposal by its idempotency key (feedback distillation — §10). Returns the
-     * proposal id if one already exists for this user + key, else null, letting proposeExtracted skip
-     * a duplicate crash-safely (the key survives a worker restart mid-sweep).
-     */
-    findProposalByIdempotencyKey(userId: string, idempotencyKey: string): string | null;
-    /**
-     * List proposals by status (oldest first) — the read side of the proposal
-     * consumer. Pending proposals from implicit-extract / feedback / dream used
-     * to have NO reader at all: they accumulated forever and never became
-     * searchable memories.
-     */
-    listProposalsByStatus(userId: string, status: MemoryProposalStatus, limit?: number): MemoryProposalRecord[];
-    /** Bulk status transition for the proposal consumer (corroborated / expired). */
-    markProposalsStatus(ids: string[], status: MemoryProposalStatus): number;
-    updateProposalStatus(id: string, status: MemoryProposalStatus, relatedClaimIds?: string[]): boolean;
-    insertClaim(input: MemoryClaimInput): string;
-    listClaims(userId: string, statuses?: MemoryClaimStatus[]): MemoryClaimRecord[];
-    findClaimsByFact(userId: string, entity: string, predicate: string, validTime?: string): MemoryClaimRecord[];
-    mergeClaimEvidence(id: string, evidenceIds: string[], confidence: number, importance: number): boolean;
-    updateClaimsByMemoryId(memoryId: string, status: MemoryClaimStatus): number;
-    insertConflict(input: {
-        userId: string;
-        claimAId: string;
-        claimBId: string;
-        reason: string;
-    }): string;
-    listConflicts(userId: string): MemoryConflictRecord[];
-    getClaimById(id: string): MemoryClaimRecord | undefined;
-    setClaimStatus(id: string, status: MemoryClaimStatus): boolean;
-    /** Mark a conflict resolved (the resolver has already updated the claims). */
-    setConflictStatus(id: string, status: "open" | "resolved" | "dismissed"): boolean;
-    /** Open conflicts only (the ones needing resolution). */
-    listOpenConflicts(userId: string): MemoryConflictRecord[];
-    /**
-     * Promote pending_confirmation claims that have accumulated enough independent
-     * evidence to become active. Returns the number promoted.
-     */
-    promotePendingClaims(userId: string, minEvidence: number): number;
-    insertAttachment(input: MemoryAttachmentInsert): void;
-    getAttachmentById(id: string): MemoryAttachmentRow | null;
-    listAttachmentsByMemoryId(memoryId: string): MemoryAttachmentRow[];
-    /** Batch-load attachments for many memories (for atlas windows). */
-    listAttachmentsByMemoryIds(memoryIds: string[]): Map<string, MemoryAttachmentRow[]>;
-    /** Link orphan/owned attachments to a committed memory. Returns linked count. */
-    linkAttachments(memoryId: string, attachmentIds: string[], userId: string): number;
-    setAttachmentExtractedText(id: string, text: string): boolean;
-    /** Delete attachment index rows for a memory; returns their rel paths for file cleanup. */
-    deleteAttachmentsByMemoryId(memoryId: string): string[];
-    /** Orphan attachments (uploaded but never saved to a memory) older than cutoff. */
-    listOrphanAttachments(cutoff: number): MemoryAttachmentRow[];
-    deleteAttachmentById(id: string): void;
-    close(): void;
-}

package/dist/types/skills/memory/memory-attachment-store.d.ts

@@ -1,62 +0,0 @@
-/**
- * MemoryAttachmentStore — persistent attachment storage for long-term memory.
- *
- * Files live beside the memory DB, with no expiry:
- *   ~/.qlogicagent/profiles/<owner>/memory/attachments/<id><ext>
- * The DB (`memory_attachments` table, via LocalMemoryStore) is the index;
- * this class owns the on-disk bytes + ties index rows to files.
- *
- * Lifecycle: an attachment is `adopt`ed at upload time (orphan, memory_id=''),
- * then `link`ed to a memory at commit; on memory delete the files+rows are
- * removed; long-orphaned uploads are purged.
- */
-import type { LocalMemoryStore, MemoryAttachmentRef, MemoryAttachmentRow } from "./local-store.js";
-export declare const MAX_ATTACHMENT_BYTES: number;
-export type AttachmentKind = "image" | "audio" | "video" | "doc" | "file";
-export declare function attachmentKindFromMime(mimeType: string, filename?: string): AttachmentKind;
-export interface AdoptedAttachment {
-    id: string;
-    kind: AttachmentKind;
-    filename: string;
-    mimeType: string;
-    size: number;
-    url: string;
-}
-export interface AdoptInput {
-    /** Raw bytes (preferred). */
-    data?: Buffer;
-    /** Or a URL the store fetches (e.g. the gateway's temp MediaStore url). */
-    sourceUrl?: string;
-    filename: string;
-    mimeType: string;
-    userId: string;
-}
-export declare class MemoryAttachmentStore {
-    private readonly store;
-    private readonly dir;
-    constructor(store: LocalMemoryStore, dir: string);
-    urlFor(id: string): string;
-    toRef(row: MemoryAttachmentRow): MemoryAttachmentRef;
-    /** Persist an uploaded file + create an orphan index row (memory_id=''). */
-    adopt(input: AdoptInput): Promise<AdoptedAttachment>;
-    /** Read an attachment's bytes + mime (for multimodal understanding). */
-    readBytes(id: string): Promise<{
-        bytes: Buffer;
-        mimeType: string;
-    } | null>;
-    /** Resolve an attachment to an absolute on-disk path (for serving). Guards traversal. */
-    locate(id: string): Promise<{
-        absPath: string;
-        mimeType: string;
-        filename: string;
-    } | null>;
-    link(memoryId: string, attachmentIds: string[], userId: string): number;
-    setExtractedText(id: string, text: string): void;
-    refsForMemory(memoryId: string): MemoryAttachmentRef[];
-    /** Map of memoryId → refs, for atlas windows. */
-    refsForMemories(memoryIds: string[]): Map<string, MemoryAttachmentRef[]>;
-    /** Remove all files + index rows for a deleted memory. */
-    removeByMemoryId(memoryId: string): Promise<void>;
-    /** Purge uploads that were never linked to a saved memory. */
-    purgeOrphans(olderThanMs?: number): Promise<void>;
-}

package/dist/types/skills/memory/memory-consolidation.d.ts

@@ -1,64 +0,0 @@
-import { LocalMemoryStore } from "./local-store.js";
-/** A pre-extracted memory item ready to be stored (no LLM needed). */
-export interface ExtractedMemoryItem {
-    text: string;
-    category?: string;
-    importance?: number;
-    speaker?: string;
-    event_date?: string;
-    tags?: string[];
-    /** Ids of already-uploaded attachments to link to this memory on commit. */
-    attachmentIds?: string[];
-    /**
-     * Explicit confidence for evidence-bearing sources (feedback distillation — §10). When set,
-     * proposeExtracted uses it verbatim instead of the source-derived default. Other callers omit it.
-     */
-    confidence?: number;
-    /**
-     * Evidence trail for distillation-style sources. `refs` (e.g. feedbackIds + turn:<id>) is stored
-     * on the observation for audit; `idempotencyKey` makes the proposal insert crash-safe + dedup'd.
-     */
-    evidence?: {
-        kind: string;
-        refs: string[];
-        idempotencyKey: string;
-    };
-}
-export interface MemoryConsolidationOptions {
-    source?: string;
-    sessionId?: string;
-}
-export interface MemoryConsolidationResult {
-    observationsAdded: number;
-    proposalsAdded: number;
-    claimsAdded: number;
-    conflictsAdded: number;
-    memoriesAdded: number;
-    observationIds: string[];
-    proposalIds: string[];
-    claimIds: string[];
-    conflictIds: string[];
-}
-export declare class MemoryConsolidator {
-    private readonly store;
-    private readonly embed;
-    constructor(store: LocalMemoryStore, embed: (text: string) => Promise<Float32Array | undefined>);
-    observe(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
-    proposeExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
-    commitExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryConsolidationOptions): Promise<MemoryConsolidationResult>;
-    /**
-     * Find an existing active memory that is a near-duplicate of `text`.
-     * Token containment (Latin/digit words + CJK bigrams) against recent
-     * memories; digit-bearing token mismatches veto the match because numbers
-     * and ids are precise facts, not phrasing variance.
-     */
-    private findNearDuplicateMemory;
-}
-/** Containment threshold above which two texts count as the same memory.
- * Exported: the proposal consumer uses the SAME bar to group same-fact proposals. */
-export declare const NEAR_DUPLICATE_CONTAINMENT = 0.82;
-/** Latin/digit words plus CJK character bigrams from normalized text. */
-export declare function dedupTokens(text: string): Set<string>;
-/** True when either side has a digit-bearing token the other side lacks. */
-export declare function digitTokensDiffer(a: Set<string>, b: Set<string>): boolean;
-export declare function sourcePriorityOf(source: string): number;

package/dist/types/skills/memory/memory-db-path.d.ts

@@ -1,13 +0,0 @@
-import type { PathService } from "../../runtime/ports/index.js";
-/**
- * Resolve the database file path for L2 vector memory storage.
- * L2 vector memory is cross-project for one owner, but physically isolated by
- * profile at ~/.qlogicagent/profiles/<owner_user_id>/memory/.
- */
-export declare function resolveMemoryDbPath(ownerUserId?: string, pathService?: PathService): string;
-/**
- * Persistent attachment directory for long-term memory, beside the memory DB:
- * ~/.qlogicagent/profiles/<owner_user_id>/memory/attachments/
- * Files here live as long as the memories that reference them (no expiry).
- */
-export declare function resolveMemoryAttachmentsDir(ownerUserId?: string, pathService?: PathService): string;

package/dist/types/skills/memory/proposal-consumer.d.ts

@@ -1,51 +0,0 @@
-/**
- * Proposal consumer (P0 — the factual-memory half of the promotion ladder).
- *
- * implicit-extract / feedback-distillation / dream all write PROPOSALS
- * (status=pending). Before this module existed nothing ever read them back:
- * the three automatic learning paths burned model calls writing dead rows.
- *
- * Trust ladder — evidence gates autonomy, mirroring the V3 skill-promotion
- * doctrine (automatic only when the data says so; visible; revertible):
- *   - CORROBORATED: the same fact proposed >=2 times from independent
- *     contexts (different session, or different source) -> auto-commit as
- *     source "corroborated" (priority 70, so it actually becomes an active
- *     searchable memory — committing with the original implicit-extract
- *     priority 40 would just create another pending claim, i.e. the black
- *     hole one level deeper).
- *   - feedback-distillation proposals commit ALONE: their >=2-evidence bar
- *     was already enforced upstream (MIN_EVIDENCE + idempotency key, §10).
- *   - dream-tier sources (priority <= 20) never commit alone; they only
- *     corroborate facts seen elsewhere.
- *   - Everything else waits, and past the TTL flips to status "expired" —
- *     a visible terminal state, not a silent delete; the memory surface can
- *     still show expired proposals for manual rescue.
- *
- * Pure planning logic — no I/O; the provider executes the plan.
- */
-import type { MemoryProposalRecord } from "./local-store-records.js";
-import type { ExtractedMemoryItem } from "./memory-consolidation.js";
-/** Uncorroborated proposals older than this flip to "expired". */
-export declare const PROPOSAL_TTL_MS: number;
-/** Independent contexts required for auto-commit. */
-export declare const PROPOSAL_MIN_CORROBORATION = 2;
-/** Idle-pass work cap; the rest stays pending for the next pass. */
-export declare const PROPOSAL_MAX_COMMITS_PER_PASS = 20;
-/** Source stamped on corroborated commits — registered in sourcePriorityOf. */
-export declare const CORROBORATED_SOURCE = "corroborated";
-export interface ProposalCommitGroup {
-    proposalIds: string[];
-    item: ExtractedMemoryItem;
-    /** Source used for the commit (drives claim authority). */
-    source: string;
-}
-export interface ProposalConsumptionSummary {
-    commitGroups: ProposalCommitGroup[];
-    expiredIds: string[];
-}
-export interface ProposalConsumptionOptions {
-    now?: number;
-    ttlMs?: number;
-    maxCommitsPerPass?: number;
-}
-export declare function planProposalConsumption(pending: readonly MemoryProposalRecord[], opts?: ProposalConsumptionOptions): ProposalConsumptionSummary;

package/dist/types/skills/memory/sqlite-memory-mappers.d.ts

@@ -1,7 +0,0 @@
-import type { MemoryClaimRecord, MemoryConflictRecord, MemoryProposalRecord, MemoryRecord } from "./local-store-records.js";
-export declare function rowToRecord(row: unknown): MemoryRecord;
-export declare function rowToClaimRecord(row: unknown): MemoryClaimRecord;
-export declare function rowToProposalRecord(row: unknown): MemoryProposalRecord;
-export declare function rowToConflictRecord(row: unknown): MemoryConflictRecord;
-export declare function parseJsonObject(raw: unknown): Record<string, unknown>;
-export declare function parseJsonArray(raw: unknown): string[];

package/dist/types/skills/memory/sqlite-memory-schema.d.ts

@@ -1,11 +0,0 @@
-import type { SqliteDatabase } from "./local-store-records.js";
-export declare const MEMORY_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS memories (\n  id TEXT PRIMARY KEY,\n  text TEXT NOT NULL,\n  user_id TEXT NOT NULL,\n  category TEXT NOT NULL DEFAULT 'general',\n  importance REAL NOT NULL DEFAULT 0.5,\n  confidence REAL NOT NULL DEFAULT 1.0,\n  source TEXT NOT NULL DEFAULT 'agent',\n  session_id TEXT NOT NULL DEFAULT '',\n  event_date TEXT NOT NULL DEFAULT '',\n  tags TEXT NOT NULL DEFAULT '[]',\n  embedding BLOB,\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL,\n  access_count INTEGER NOT NULL DEFAULT 0,\n  last_accessed_at INTEGER NOT NULL DEFAULT 0,\n  is_archived INTEGER NOT NULL DEFAULT 0,\n  text_seg TEXT NOT NULL DEFAULT '',\n  embedding_model TEXT NOT NULL DEFAULT '',\n  embedding_dims INTEGER NOT NULL DEFAULT 0\n);\n\nCREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id);\nCREATE INDEX IF NOT EXISTS idx_memories_user_category ON memories(user_id, category);\nCREATE INDEX IF NOT EXISTS idx_memories_user_importance ON memories(user_id, importance DESC);\nCREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at DESC);\n\nCREATE TABLE IF NOT EXISTS memory_observations (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  text TEXT NOT NULL,\n  source TEXT NOT NULL,\n  source_priority INTEGER NOT NULL DEFAULT 0,\n  session_id TEXT NOT NULL DEFAULT '',\n  evidence_type TEXT NOT NULL DEFAULT 'text',\n  payload TEXT NOT NULL DEFAULT '{}',\n  created_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_observations_user_created ON memory_observations(user_id, created_at DESC);\nCREATE INDEX IF NOT EXISTS idx_memory_observations_source ON memory_observations(user_id, source);\n\nCREATE TABLE IF NOT EXISTS memory_proposals (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  observation_ids TEXT NOT NULL DEFAULT '[]',\n  text TEXT NOT NULL,\n  category TEXT NOT NULL DEFAULT 'general',\n  importance REAL NOT NULL DEFAULT 0.5,\n  confidence REAL NOT NULL DEFAULT 0.5,\n  source TEXT NOT NULL DEFAULT 'agent',\n  source_priority INTEGER NOT NULL DEFAULT 0,\n  entity TEXT NOT NULL DEFAULT '',\n  predicate TEXT NOT NULL DEFAULT '',\n  value_json TEXT NOT NULL DEFAULT '{}',\n  valid_time TEXT NOT NULL DEFAULT '',\n  tags TEXT NOT NULL DEFAULT '[]',\n  status TEXT NOT NULL DEFAULT 'pending',\n  related_claim_ids TEXT NOT NULL DEFAULT '[]',\n  idempotency_key TEXT,\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_proposals_user_status ON memory_proposals(user_id, status);\nCREATE INDEX IF NOT EXISTS idx_memory_proposals_fact ON memory_proposals(user_id, entity, predicate, valid_time);\n\nCREATE TABLE IF NOT EXISTS memory_claims (\n  id TEXT PRIMARY KEY,\n  memory_id TEXT NOT NULL DEFAULT '',\n  user_id TEXT NOT NULL,\n  entity TEXT NOT NULL DEFAULT '',\n  predicate TEXT NOT NULL DEFAULT '',\n  value_json TEXT NOT NULL DEFAULT '{}',\n  text TEXT NOT NULL,\n  category TEXT NOT NULL DEFAULT 'general',\n  importance REAL NOT NULL DEFAULT 0.5,\n  confidence REAL NOT NULL DEFAULT 0.5,\n  source TEXT NOT NULL DEFAULT 'agent',\n  source_priority INTEGER NOT NULL DEFAULT 0,\n  status TEXT NOT NULL DEFAULT 'active',\n  valid_time TEXT NOT NULL DEFAULT '',\n  evidence_ids TEXT NOT NULL DEFAULT '[]',\n  supersedes_claim_id TEXT NOT NULL DEFAULT '',\n  conflict_group_id TEXT NOT NULL DEFAULT '',\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_claims_user_status ON memory_claims(user_id, status);\nCREATE INDEX IF NOT EXISTS idx_memory_claims_memory ON memory_claims(memory_id);\nCREATE INDEX IF NOT EXISTS idx_memory_claims_fact ON memory_claims(user_id, entity, predicate, valid_time);\n\nCREATE TABLE IF NOT EXISTS memory_conflicts (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  claim_a_id TEXT NOT NULL,\n  claim_b_id TEXT NOT NULL,\n  reason TEXT NOT NULL,\n  status TEXT NOT NULL DEFAULT 'open',\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_conflicts_user_status ON memory_conflicts(user_id, status);\n\nCREATE TABLE IF NOT EXISTS memory_attachments (\n  id TEXT PRIMARY KEY,\n  memory_id TEXT NOT NULL DEFAULT '',\n  user_id TEXT NOT NULL,\n  kind TEXT NOT NULL DEFAULT 'file',\n  filename TEXT NOT NULL DEFAULT '',\n  mime_type TEXT NOT NULL DEFAULT '',\n  size INTEGER NOT NULL DEFAULT 0,\n  rel_path TEXT NOT NULL,\n  extracted_text TEXT NOT NULL DEFAULT '',\n  created_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_memory_attachments_memory ON memory_attachments(memory_id);\nCREATE INDEX IF NOT EXISTS idx_memory_attachments_orphan ON memory_attachments(user_id, memory_id, created_at);\n\n";
-/**
- * FTS index + sync triggers, kept as a separate DDL block because the CJK
- * migration below must DROP and re-create exactly this set — a second copy
- * would drift. The index covers the pre-segmented shadow column `text_seg`
- * (see fts-segment.ts), NOT raw `text`: unicode61 cannot segment CJK, so raw
- * Chinese text is unsearchable by keyword.
- */
-export declare const MEMORY_FTS_SCHEMA_SQL = "\nCREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(\n  id UNINDEXED,\n  user_id UNINDEXED,\n  text_seg,\n  category,\n  tags,\n  content=memories,\n  content_rowid=rowid,\n  tokenize='unicode61 remove_diacritics 2'\n);\n\nCREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN\n  INSERT INTO memories_fts(rowid, id, user_id, text_seg, category, tags)\n  VALUES (new.rowid, new.id, new.user_id, new.text_seg, new.category, new.tags);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN\n  INSERT INTO memories_fts(memories_fts, rowid, id, user_id, text_seg, category, tags)\n  VALUES ('delete', old.rowid, old.id, old.user_id, old.text_seg, old.category, old.tags);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN\n  INSERT INTO memories_fts(memories_fts, rowid, id, user_id, text_seg, category, tags)\n  VALUES ('delete', old.rowid, old.id, old.user_id, old.text_seg, old.category, old.tags);\n  INSERT INTO memories_fts(rowid, id, user_id, text_seg, category, tags)\n  VALUES (new.rowid, new.id, new.user_id, new.text_seg, new.category, new.tags);\nEND;\n";
-export declare function initializeMemorySchema(db: SqliteDatabase): void;