qlogicagent 2.10.50 → 2.11.1

package/dist/types/protocol/wire/thread-protocol.d.ts

@@ -132,18 +132,6 @@ export interface ThreadCreateParams {
     /** LLM configuration. */
     config?: Record<string, unknown>;
 }
-/** `thread/turn` params — submit a user message to a thread. */
-export interface ThreadTurnParams {
-    /** Thread ID. */
-    threadId: string;
-    /** User message(s). */
-    messages: Array<{
-        role: "user";
-        content: string;
-    }>;
-    /** Override LLM config for this turn. */
-    config?: Record<string, unknown>;
-}
 /** `thread/list` result. */
 export interface ThreadListResult {
     threads: Array<{

package/dist/types/runtime/infra/acp-detector.d.ts

@@ -8,6 +8,11 @@
  */
 import type { AcpBackendConfig, AgentDescriptor, AgentConfigStoreData } from "../../protocol/wire/acp-agent-management.js";
 export declare const ACP_BACKENDS: Record<string, AcpBackendConfig>;
+export declare function resolveWindowsCopilotLoader(): string | null;
+export declare function normalizeWindowsAcpCommand(cliPath: string, args: string[]): {
+    cliPath: string;
+    acpArgs: string[];
+};
 export declare class AcpDetector {
     private cache;
     private configStore;

package/dist/types/runtime/infra/acp-host-handler.d.ts

@@ -0,0 +1,23 @@
+import type { AcpHostRequestHandler } from "./acp-protocol-adapter.js";
+interface HostHandlerOpts {
+    cwd: string;
+}
+/**
+ * Host-side reverse-RPC handler for an EXTERNAL ACP agent (codex/copilot/…).
+ *
+ * Auto-allows permissions (the external agent runs under the qlogicagent host's
+ * trust, matching the internal sub-agent baseline), serves fs read/write confined
+ * to the agent cwd, and runs terminals as real child processes. Terminals are
+ * tracked in a Map so the agent process lifecycle (detach/kill) can reap them via
+ * disposeAll().
+ *
+ * Terminal response shapes align with the official ACP schema
+ * (@zed-industries/agent-client-protocol):
+ *   - createTerminal       -> { terminalId }
+ *   - terminalOutput       -> { output, truncated, exitStatus: {exitCode, signal} | null }
+ *   - waitForTerminalExit  -> { exitCode, signal }
+ */
+export declare function createAcpHostHandler(opts: HostHandlerOpts): AcpHostRequestHandler & {
+    disposeAll(): void;
+};
+export {};

package/dist/types/runtime/pet/index.d.ts

@@ -3,9 +3,9 @@
  */
 export { PetSoulService } from "./pet-soul-service.js";
 export type { PetSoul, PetStats, PetBreed } from "./pet-types.js";
-export { PetProfileService, type PetProfile, type PetPreferences, type PetCustomPet, type PetCustomPetSummary, type JourneySnapshot } from "./pet-profile-service.js";
+export { PetProfileService, type PetProfile, type PetPreferences, type PetdexPetAsset, type PetdexPetAssetSummary, type JourneySnapshot } from "./pet-profile-service.js";
+export { PETDEX_ANIMATION_IDS, createPetdexAssetFromSpritesheet, listBuiltinPetdexAssetIds, listBuiltinPetdexAssets, petdexImageDataUrl, toPetdexAssetSummary, writePetdexAssetPackage, type PetdexAnimationId, type PetdexValidationReport } from "./petdex-asset.js";
+export { buildPetdexAtlasPrompt, forgePetdexAsset, forgePetdexAssetPackage, readGeneratedPetdexImage } from "./petdex-forge-service.js";
 export { maybeGenerateReaction, generateLLMReaction, type ReactionPool, type LLMReactionContext, type ReactionStyle } from "./pet-reaction-service.js";
 export { PetGrowthEngine, type GrowthEvent, type MoltResult, type PetDisplayTrait } from "./pet-growth-engine.js";
-export { loadPetFile, validatePetManifest, sanitizeSvg, type PetManifest, type PetFileBundle } from "./pet-file-loader.js";
-export { buildSkeletonPrompt, parseSkeleton, renderState, extractColors, validateSkeleton, STATE_ANIMATION_MAP, type PetSkeleton, type SkeletonPart, type StateAnimationParams } from "./pet-skeleton.js";
-export { evaluateConsistency, evaluateConsistencyWithVision, structuralConsistencyScore, buildConsistencyPrompt, parseConsistencyResponse, buildRetryPrompt, DEFAULT_THRESHOLD, DEFAULT_MAX_RETRIES, type ConsistencyResult, type ConsistencyReport, type ConsistencyOptions } from "./pet-consistency.js";
+export { loadPetFile, validatePetManifest, type PetManifest, type PetFileBundle } from "./pet-file-loader.js";

package/dist/types/runtime/pet/pet-file-loader.d.ts

@@ -1,62 +1,5 @@
-/**
- * Pet File Loader — loads, validates, and sanitizes .pet bundles.
- *
- * Design §14.2: .pet is a zip file containing manifest.json + SVG states + thumbnail.
- * Design §16.2: Security — SVG sanitize (remove scripts, foreign objects, event handlers).
- *
- * This module handles:
- * - Zip extraction
- * - Manifest JSON Schema validation
- * - SVG sanitization (whitelist-based)
- * - File size enforcement
- */
-export interface PetManifest {
-    version: number;
-    name: string;
-    author: string;
-    created: string;
-    generator?: string;
-    source?: {
-        type: "image" | "text" | "dialogue";
-        prompt?: string;
-    };
-    dimensions: {
-        width: number;
-        height: number;
-    };
-    states: Record<string, {
-        file: string;
-        loop: boolean;
-        duration?: number;
-    }>;
-    eyeTracking?: {
-        enabled: boolean;
-        pupils: string[];
-        maxOffset: number;
-    };
-    colors?: {
-        primary: string;
-        secondary?: string;
-        accent?: string;
-    };
-}
-export interface PetFileBundle {
-    manifest: PetManifest;
-    svgs: Record<string, string>;
-    thumbnail?: string;
-    hash: string;
-}
-/**
- * Load and validate a .pet file from disk.
- * Returns a PetFileBundle with sanitized SVGs, or throws on validation failure.
- */
+import { type PetdexAssetManifest, type PetdexAssetPackage, type PetdexAssetValidation } from "./petdex-asset.js";
+export type PetManifest = PetdexAssetManifest;
+export type PetFileBundle = PetdexAssetPackage;
 export declare function loadPetFile(filePath: string): Promise<PetFileBundle>;
-/**
- * Validate manifest structure. Throws on invalid.
- */
-export declare function validatePetManifest(manifest: unknown): asserts manifest is PetManifest;
-/**
- * Sanitize SVG content — remove dangerous elements and attributes.
- * Whitelist-based approach (design §16.2).
- */
-export declare function sanitizeSvg(svgContent: string): string;
+export declare function validatePetManifest(manifest: unknown, spritesheet?: Buffer): PetdexAssetValidation;

package/dist/types/runtime/pet/pet-profile-service.d.ts

@@ -1,19 +1,52 @@
 import type { PetSoul } from "./pet-types.js";
 export interface PetPreferences {
     enabled: boolean;
-    selectedBreed: string;
-    selectedCustomPetId: string | null;
+    selectedPetAssetId: string;
 }
-export interface PetCustomPetSummary {
+export interface PetdexPetAssetSummary {
     id: string;
+    assetKind: "petdex";
+    sourceKind?: "builtin" | "upload" | "forge";
     name: string;
     description: string;
     createdAt: string;
     updatedAt: string;
+    atlas: PetdexPetAssetSummaryAtlas;
+    animations?: Record<string, PetdexPetAnimation>;
+    thumbnail?: {
+        frame: number;
+    };
 }
-export interface PetCustomPet extends PetCustomPetSummary {
-    svgs: Record<string, string>;
-    sourcePrompt?: string;
+export interface PetdexPetAssetSummaryAtlas {
+    format: "webp";
+    columns: 8;
+    rows: 9;
+    frameCount: 72;
+    cellWidth: 192;
+    cellHeight: 208;
+    width: 1536;
+    height: 1872;
+    sha256: string;
+}
+export interface PetdexPetAssetAtlas extends PetdexPetAssetSummaryAtlas {
+    image: "spritesheet.webp";
+}
+export interface PetdexPetAnimation {
+    frames: number[];
+    fps: number;
+    loop: boolean;
+}
+export interface PetdexPetAsset extends Omit<PetdexPetAssetSummary, "atlas"> {
+    schema: "qlogic.petdex.asset.v1";
+    atlas: PetdexPetAssetAtlas;
+    source: {
+        kind: "builtin" | "upload" | "forge";
+        prompt: string | null;
+    };
+    animations: Record<string, PetdexPetAnimation>;
+    thumbnail: {
+        frame: number;
+    };
 }
 export interface JourneySnapshot {
     date: string;
@@ -27,7 +60,7 @@ export interface PetProfile {
     ownerUserId: string;
     soul: PetSoul | null;
     preferences: PetPreferences;
-    customPets: PetCustomPetSummary[];
+    customPets: PetdexPetAssetSummary[];
     journeyDates: string[];
     updatedAt: string;
 }
@@ -42,10 +75,18 @@ export declare class PetProfileService {
     saveJourneySnapshot(snapshot: JourneySnapshot): PetProfile;
     listJourneyDates(): string[];
     getJourneySnapshot(date: string): JourneySnapshot | null;
-    upsertCustomPet(pet: PetCustomPet): PetProfile;
+    upsertCustomPet(pet: PetdexPetAsset): PetProfile;
     deleteCustomPet(id: string): PetProfile;
-    listCustomPets(): PetCustomPet[];
-    getCustomPet(id: string): PetCustomPet | null;
+    listCustomPets(): PetdexPetAssetSummary[];
+    getCustomPet(id: string): PetdexPetAsset | null;
+    getCustomPetSpritesheet(id: string): Buffer | null;
+    findReusableCustomPetId(params: {
+        sourceKind: "upload" | "forge";
+        name: string;
+        description: string;
+    }): string | null;
+    compactDuplicateCustomPets(): PetProfile;
+    writeCustomPetAssetFiles(pet: PetdexPetAsset, spritesheet: Buffer, validation: unknown, productionRun?: unknown): PetProfile;
     private defaultProfile;
     private normalizeProfile;
     private writeProfile;

package/dist/types/runtime/pet/petdex-asset.d.ts

@@ -0,0 +1,138 @@
+export declare const PETDEX_SCHEMA: "qlogic.petdex.asset.v1";
+export declare const PETDEX_VALIDATION_SCHEMA: "qlogic.petdex.validation.v1";
+export declare const PETDEX_ATLAS_CONTRACT: {
+    readonly format: "webp";
+    readonly columns: 8;
+    readonly rows: 9;
+    readonly frameCount: 72;
+    readonly cellWidth: 192;
+    readonly cellHeight: 208;
+    readonly width: 1536;
+    readonly height: 1872;
+};
+export declare const PETDEX_ANIMATION_IDS: readonly ["idle", "thinking", "working", "done", "happy", "error", "attention", "dragging", "sleeping"];
+export type PetdexAnimationId = typeof PETDEX_ANIMATION_IDS[number];
+export interface PetdexAnimation {
+    frames: number[];
+    fps: number;
+    loop: boolean;
+}
+export interface PetdexAtlas {
+    image: "spritesheet.webp";
+    format: "webp";
+    columns: 8;
+    rows: 9;
+    frameCount: 72;
+    cellWidth: 192;
+    cellHeight: 208;
+    width: 1536;
+    height: 1872;
+    sha256: string;
+    imageUrl?: string;
+}
+export interface PetdexAssetSource {
+    kind: "builtin" | "upload" | "forge";
+    prompt: string | null;
+}
+export interface PetdexPetAsset {
+    schema: typeof PETDEX_SCHEMA;
+    id: string;
+    assetKind: "petdex";
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+    source: PetdexAssetSource;
+    atlas: PetdexAtlas;
+    animations: Record<PetdexAnimationId, PetdexAnimation>;
+    thumbnail: {
+        frame: number;
+    };
+    sourcePrompt?: string;
+}
+export type PetdexAssetManifest = PetdexPetAsset;
+export interface PetdexPetAssetSummary {
+    id: string;
+    assetKind: "petdex";
+    sourceKind: PetdexAssetSource["kind"];
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+    atlas: Omit<PetdexAtlas, "image" | "imageUrl"> & {
+        imageUrl?: string;
+    };
+    animations?: Record<PetdexAnimationId, PetdexAnimation>;
+    thumbnail?: {
+        frame: number;
+    };
+}
+export interface PetdexValidationReport {
+    schema: typeof PETDEX_VALIDATION_SCHEMA;
+    assetId: string;
+    valid: boolean;
+    validatedAt: string;
+    errors: string[];
+    warnings: string[];
+    atlas: {
+        format: "webp";
+        columns: 8;
+        rows: 9;
+        frameCount: 72;
+        cellWidth: 192;
+        cellHeight: 208;
+        width: number;
+        height: number;
+        sha256: string;
+    };
+    animations: {
+        ids: PetdexAnimationId[];
+        minFrame: number;
+        maxFrame: number;
+    };
+}
+export interface LoadedPetdexPackage {
+    manifest: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+}
+export type PetdexAssetPackage = LoadedPetdexPackage;
+export type PetdexAssetValidation = PetdexValidationReport;
+export interface PetdexImportResult {
+    asset: PetdexPetAsset;
+    summary: PetdexPetAssetSummary;
+    validation: PetdexValidationReport;
+}
+export declare function createDefaultPetdexAnimations(): Record<PetdexAnimationId, PetdexAnimation>;
+export declare function toPetdexAssetSummary(asset: PetdexPetAsset, imageUrl?: string): PetdexPetAssetSummary;
+export declare function validatePetdexAssetManifest(manifest: unknown, spritesheet: Buffer): PetdexValidationReport;
+export declare function loadPetdexAssetPackage(filePath: string): Promise<LoadedPetdexPackage>;
+export declare function buildPetdexAssetImport(filePath: string, targetDir: string): Promise<PetdexImportResult>;
+export declare function writePetdexAssetPackage(params: {
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+    productionRun?: unknown;
+    outputDir: string;
+    fileName?: string;
+}): Promise<string>;
+export declare function createPetdexAssetFromSpritesheet(params: {
+    id?: string;
+    name: string;
+    description: string;
+    prompt?: string | null;
+    spritesheet: Buffer;
+    now?: string;
+    sourceKind?: PetdexAssetSource["kind"];
+}): Promise<{
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+}>;
+export declare function listBuiltinPetdexAssetIds(): string[];
+export declare function listBuiltinPetdexAssets(): Promise<Array<{
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+}>>;
+export declare function petdexImageDataUrl(spritesheet: Buffer): string;

package/dist/types/runtime/pet/petdex-forge-service.d.ts

@@ -0,0 +1,110 @@
+import { PETDEX_ATLAS_CONTRACT, type PetdexAnimationId, type PetdexPetAsset, type PetdexValidationReport } from "./petdex-asset.js";
+export interface PetdexForgeRequest {
+    id?: string;
+    name: string;
+    description: string;
+    prompt?: string | null;
+    referenceImageUrl?: string;
+    referenceMode?: "identity" | "refine";
+    baseSpritesheet?: Buffer;
+    refineAnimationId?: PetdexAnimationId;
+    refineFrameIndexes?: number[];
+}
+export interface PetdexImageGenerationRequest {
+    prompt: string;
+    purpose: "petdex-reference" | "petdex-row-strip";
+    animationId?: PetdexAnimationId;
+    style: string;
+    size: string;
+    imageUrl?: string;
+    referenceImages?: PetdexProductionReferenceImage[];
+    n: 1;
+    quality: "auto";
+}
+export interface PetdexImageGenerationResult {
+    mediaUrls: string[];
+    model?: string;
+    size?: string;
+    durationMs?: number;
+    provider?: string;
+    billingUnit?: string;
+    billingQuantity?: number;
+}
+export interface PetdexForgeOutput {
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    validation: PetdexValidationReport;
+    prompt: string;
+    productionRun: PetdexProductionRun;
+    model?: string;
+    size?: string;
+    durationMs?: number;
+    mediaUsage?: {
+        provider: string;
+        model: string;
+        billingUnit: string;
+        billingQuantity: number;
+    };
+}
+export declare const PETDEX_PRODUCTION_SCHEMA: "qlogic.petdex.production.v1";
+export interface PetdexProductionReferenceImage {
+    role: "canonical-reference" | "layout-guide" | "existing-atlas";
+    imageUrl: string;
+}
+export interface PetdexProductionJob {
+    id: string;
+    kind: "reference" | "row-strip";
+    status: "complete";
+    animationId?: PetdexAnimationId;
+    prompt: string;
+    inputImages: PetdexProductionReferenceImage[];
+    outputUrl: string;
+}
+export interface PetdexProductionRun {
+    schema: typeof PETDEX_PRODUCTION_SCHEMA;
+    status: "complete";
+    sourceMode: "text" | "reference" | "refine";
+    contract: typeof PETDEX_ATLAS_CONTRACT;
+    jobs: PetdexProductionJob[];
+    qa: {
+        contactSheet: {
+            rows: typeof PETDEX_ATLAS_CONTRACT.rows;
+            columns: typeof PETDEX_ATLAS_CONTRACT.columns;
+            frameCount: typeof PETDEX_ATLAS_CONTRACT.frameCount;
+        };
+        rowReports: Array<{
+            animationId: PetdexAnimationId;
+            status: "pass";
+            frames: typeof PETDEX_ATLAS_CONTRACT.columns;
+        }>;
+    };
+}
+export interface PetdexForgePackageOutput extends PetdexForgeOutput {
+    packagePath: string;
+    assetDir: string;
+    manifestPath: string;
+    spritesheetPath: string;
+    validationPath: string;
+    productionRunPath: string;
+}
+export type GeneratePetdexImage = (request: PetdexImageGenerationRequest) => Promise<PetdexImageGenerationResult>;
+export type UploadPetdexReferenceImage = (input: {
+    buffer: Buffer;
+    mimeType: string;
+    filename: string;
+}) => Promise<string>;
+export interface PetdexProductionOptions {
+    uploadReferenceImage?: UploadPetdexReferenceImage;
+}
+export declare function forgePetdexAsset(input: PetdexForgeRequest, generateImage: GeneratePetdexImage, options?: PetdexProductionOptions): Promise<PetdexForgeOutput>;
+export declare function forgePetdexAssetPackage(params: {
+    input: PetdexForgeRequest;
+    outputDir: string;
+    generateImage: GeneratePetdexImage;
+    uploadReferenceImage?: UploadPetdexReferenceImage;
+}): Promise<PetdexForgePackageOutput>;
+export declare function buildPetdexAtlasPrompt(description: string, prompt?: string | null, referenceMode?: "identity" | "refine"): string;
+export declare function buildPetdexCharacterPrompt(description: string, prompt?: string | null, referenceMode?: "identity" | "refine"): string;
+export declare function buildPetdexReferencePrompt(description: string, prompt?: string | null, referenceMode?: "identity" | "refine"): string;
+export declare function buildPetdexRowPrompt(animationId: PetdexAnimationId, description: string, prompt?: string | null, referenceMode?: "identity" | "refine"): string;
+export declare function readGeneratedPetdexImage(mediaUrl: string): Promise<Buffer>;

package/dist/types/runtime/ports/memory-provider.d.ts

@@ -33,6 +33,8 @@ export interface MemoryExtractionItem {
     source?: string;
     event_date?: string;
     tags?: string[];
+    /** Ids of already-uploaded attachments to link to this memory on commit. */
+    attachmentIds?: string[];
 }
 export interface MemoryConsolidationWriteResult {
     memoriesAdded?: number;
@@ -77,6 +79,15 @@ export interface MemoryActivitySummary {
         date: string;
     }>;
 }
+/** Lightweight attachment reference carried on atlas/detail records (no bytes). */
+export interface MemoryAtlasAttachmentRef {
+    id: string;
+    kind: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    url: string;
+}
 export interface MemoryAtlasRecord {
     id: string;
     text: string;
@@ -92,6 +103,7 @@ export interface MemoryAtlasRecord {
     accessCount?: number;
     lastAccessedAt?: string | number;
     isArchived?: boolean;
+    attachments?: MemoryAtlasAttachmentRef[];
 }
 export interface MemoryAtlasResult {
     totalCount?: number;
@@ -116,6 +128,29 @@ export interface MemoryHandlerProvider extends MemoryProvider {
     proposeExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
     ingestExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
     update?(id: string, patch: MemoryUpdatePatch): Promise<boolean>;
+    /** Persist an uploaded attachment (orphan until linked at commit). */
+    adoptAttachment?(input: {
+        data?: Buffer;
+        sourceUrl?: string;
+        filename: string;
+        mimeType: string;
+        userId: string;
+    }): Promise<MemoryAtlasAttachmentRef>;
+    /** Resolve an attachment id to its on-disk path (for serving). */
+    locateAttachment?(id: string): Promise<{
+        absPath: string;
+        mimeType: string;
+        filename: string;
+    } | null>;
+    /** Drop uploads never saved to a memory. */
+    purgeOrphanAttachments?(): Promise<void>;
+    /** Read an attachment's bytes + mime (for multimodal understanding). */
+    readAttachmentBytes?(id: string): Promise<{
+        bytes: Buffer;
+        mimeType: string;
+    } | null>;
+    /** Persist understood/extracted text on an attachment row. */
+    setAttachmentText?(id: string, text: string): void;
 }
 export interface MemoryDreamProvider {
     search(query: string, userId: string, options?: {

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

@@ -10,6 +10,7 @@
  */
 import type { MemoryProvider, MemorySearchResult, MemorySearchOptions, MemoryIngestMessage, MemoryIngestOptions } from "../../protocol/wire/index.js";
 import type { MemoryClaimRecord, MemoryConflictRecord, MemoryUpdateInput, SqliteDatabase } from "./local-store.js";
+import { type AdoptedAttachment } from "./memory-attachment-store.js";
 import { type LocalEmbeddingConfig } from "./local-embedding.js";
 import { type ExtractedMemoryItem, type MemoryConsolidationResult } from "./memory-consolidation.js";
 export type { ExtractedMemoryItem } from "./memory-consolidation.js";
@@ -28,9 +29,33 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     private store;
     private embedding;
     private consolidator;
+    private attachmentStore;
     private userIdPrefix;
     private dbPath;
     constructor(config: LocalMemoryProviderConfig);
+    /** Persist an uploaded attachment (orphan until linked at commit). */
+    adoptAttachment(input: {
+        data?: Buffer;
+        sourceUrl?: string;
+        filename: string;
+        mimeType: string;
+        userId: string;
+    }): Promise<AdoptedAttachment>;
+    /** Resolve an attachment id to its on-disk path (for serving). */
+    locateAttachment(id: string): Promise<{
+        absPath: string;
+        mimeType: string;
+        filename: string;
+    } | null>;
+    /** Drop uploads that were never saved to a memory. */
+    purgeOrphanAttachments(): Promise<void>;
+    /** Read an attachment's bytes + mime (P2 multimodal understanding). */
+    readAttachmentBytes(id: string): Promise<{
+        bytes: Buffer;
+        mimeType: string;
+    } | null>;
+    /** Persist the understood/extracted text on an attachment row. */
+    setAttachmentText(id: string, text: string): void;
     private resolveUserId;
     private buildEmbedding;
     search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;

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

@@ -30,6 +30,41 @@ export interface MemoryRecord {
     accessCount: number;
     lastAccessedAt: number;
     isArchived: boolean;
+    /** Lightweight attachment refs (populated by the provider for atlas/detail). */
+    attachments?: MemoryAttachmentRef[];
+}
+/** Lightweight attachment reference carried on records / atlas wire (no bytes, no extractedText). */
+export interface MemoryAttachmentRef {
+    id: string;
+    kind: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    url: string;
+}
+/** 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 interface MemoryInsertInput {
     text: string;
@@ -416,5 +451,18 @@ export declare class LocalMemoryStore {
         reason: string;
     }): string;
     listConflicts(userId: string): MemoryConflictRecord[];
+    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;
 }