qlogicagent 2.10.22 → 2.10.24

package/dist/types/runtime/infra/skill-injector.test.d.ts

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

package/dist/types/runtime/infra/task-runtime.d.ts

@@ -9,7 +9,7 @@
  * Architecture note: CC uses React-style setAppState(prev => next). We use
  * a simple Map-based store since we're in a subprocess (no React).
  */
-import type { TaskState, TaskType, TaskLifecycle, PermissionRole, IsolationMode, LocalAgentTaskState, LocalBashTaskState } from "../../orchestration/subagent/task-types.js";
+import type { TaskState, TaskType, TaskLifecycle, PermissionRole, IsolationMode, LocalAgentTaskState, LocalBashTaskState } from "../tasks/task-types.js";
 import type { HookRegistry } from "../../contracts/hooks.js";
 /** Polling interval for running tasks (ms) */
 export declare const POLL_INTERVAL_MS = 1000;

package/dist/types/runtime/infra/worktree-backend.d.ts

@@ -17,7 +17,7 @@
  *
  * Security: validateWorktreeSlug() prevents path traversal.
  */
-import type { WorktreeToolDeps } from "../../skills/tools/worktree-tool.js";
+import type { WorktreeBackend } from "../ports/worktree-contracts.js";
 interface WorktreeSession {
     originalCwd: string;
     worktreePath: string;
@@ -82,5 +82,5 @@ export interface WorktreeBackendOptions {
     /** Sparse-checkout paths (CC settings.worktree.sparsePaths parity). */
     sparsePaths?: string[];
 }
-export declare function createWorktreeBackend(opts: WorktreeBackendOptions): WorktreeToolDeps;
+export declare function createWorktreeBackend(opts: WorktreeBackendOptions): WorktreeBackend;
 export {};

package/dist/types/runtime/memory/categories.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Memory categories for QMemory writes.
+ * Each has different value thresholds and retention policies.
+ */
+export type QMemoryCategory = "lesson" | "preference" | "pattern" | "fact" | "decision" | "skill-learning";

package/dist/types/runtime/memory/find-relevant-memories.d.ts

@@ -0,0 +1,70 @@
+export declare const RELEVANT_MEMORIES_CONFIG: {
+    /** Max topic files to consider during scan. */
+    readonly MAX_SCAN_FILES: 100;
+    /** Max files to surface per turn. */
+    readonly MAX_SELECTED: 5;
+    /** Max bytes per surfaced file (CC: 4096). */
+    readonly MAX_FILE_BYTES: 4096;
+    /** Max total bytes for all surfaced files combined. */
+    readonly MAX_TOTAL_BYTES: number;
+    /** Minimum score to be selected (0.0-1.0). */
+    readonly MIN_SCORE: 0.2;
+    /** Lines to read for header/description extraction. */
+    readonly HEADER_LINES: 10;
+    /** Recency boost: files modified within this many days get a bonus. */
+    readonly RECENCY_DAYS: 7;
+    /** Recency boost amount. */
+    readonly RECENCY_BOOST: 0.15;
+};
+/** Scanned memory file header (CC MemoryHeader parity). */
+export interface MemoryFileHeader {
+    /** Filename (e.g. "lesson-docker.md") */
+    filename: string;
+    /** Absolute path */
+    filePath: string;
+    /** Last modified timestamp (ms since epoch) */
+    mtimeMs: number;
+    /** File size in bytes */
+    sizeBytes: number;
+    /** Description extracted from first non-heading line */
+    description: string | null;
+    /** Category inferred from filename prefix */
+    category: string | null;
+}
+/** A selected relevant memory with content loaded. */
+export interface RelevantMemory {
+    /** Filename */
+    filename: string;
+    /** Full file path */
+    filePath: string;
+    /** Last modified timestamp */
+    mtimeMs: number;
+    /** Relevance score (0.0 - 1.0) */
+    score: number;
+    /** Content (possibly truncated) */
+    content: string;
+    /** Whether content was truncated */
+    truncated: boolean;
+}
+/**
+ * Find memory files relevant to a user query.
+ *
+ * CC parity: scans topic files, scores by keyword + filename + recency,
+ * selects top-N, loads content. No LLM needed (unlike CC's Sonnet call).
+ *
+ * @param query - User query text
+ * @param memoryDir - Root of the MEMDIR directory (~/.qlogicagent/memory/)
+ * @param alreadySurfaced - Paths already shown in prior turns (for dedup)
+ * @returns Relevant memories with content, sorted by score
+ */
+export declare function findRelevantMemories(query: string, memoryDir: string, alreadySurfaced?: ReadonlySet<string>): Promise<RelevantMemory[]>;
+/**
+ * Scan memory directory for topic files (excludes INDEX.md).
+ * Returns headers sorted by modification time (newest first).
+ */
+export declare function scanMemoryHeaders(memoryDir: string): Promise<MemoryFileHeader[]>;
+/**
+ * Format relevant memories as a single block for system prompt injection.
+ * CC parity: includes freshness header per file.
+ */
+export declare function formatRelevantMemoriesBlock(memories: RelevantMemory[]): string;

package/dist/types/runtime/memory/implicit-extraction.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Implicit Memory Extraction — CC extractMemories lightweight port.
+ *
+ * Architecture:
+ *   Layer 1: Zero-cost signal detection (regex) — decides if turn has extractable content
+ *   Layer 2: Lightweight LLM pass (async, non-blocking) — extracts structured facts
+ *
+ * This runs AFTER turn.end, so the user already has their response.
+ * Layer 2 only fires for ~10-20% of turns (those with detectable signals).
+ *
+ * Reference: claude-code src/services/extractMemories/extractMemories.ts
+ */
+import type { MemoryWriter } from "../ports/memory-writer.js";
+export interface ExtractedFact {
+    text: string;
+    category: "personal_fact" | "preference" | "event" | "lesson" | "pattern" | "decision";
+    importance: number;
+    eventDate?: string;
+}
+export interface ImplicitExtractionDeps {
+    /** Local memory provider for writing extracted facts. */
+    localProvider: MemoryWriter;
+    /** User ID. */
+    userId: string;
+    /** Logger. */
+    log: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+    /**
+     * LLM invocation function (uses background/cheap model).
+     * Returns structured JSON string or null if unavailable.
+     */
+    llmExtract?: (prompt: string) => Promise<string | null>;
+}
+export interface TurnPair {
+    userMessage: string;
+    assistantMessage: string;
+}
+/**
+ * Layer 1: Detect if a user message contains signals worth extracting.
+ * Zero LLM cost — pure regex scanning.
+ *
+ * @returns true if the message likely contains extractable personal facts/events
+ */
+export declare function hasExtractionSignal(userMessage: string): boolean;
+/**
+ * Layer 2: Use a lightweight LLM to extract structured facts from a turn pair.
+ * Only called when Layer 1 signals are detected.
+ */
+export declare function extractFactsViaLlm(turn: TurnPair, llmExtract: (prompt: string) => Promise<string | null>, today: string): Promise<ExtractedFact[]>;
+/**
+ * Run the full implicit extraction pipeline for a completed turn.
+ * This is async and non-blocking — call it after turn.end.
+ *
+ * @returns Number of facts extracted and stored
+ */
+export declare function runImplicitExtraction(turn: TurnPair, deps: ImplicitExtractionDeps): Promise<number>;

package/dist/types/runtime/memory/recall-category-filter.d.ts

@@ -0,0 +1,54 @@
+import type { QMemoryCategory } from "./categories.js";
+/** Detected query scenario with preferred categories. */
+export interface RecallCategoryHint {
+    /** Detected scenario label. */
+    scenario: QueryScenario;
+    /** Preferred categories for this scenario (ordered by priority). */
+    preferred: QMemoryCategory[];
+    /** Categories to deprioritize (still recalled but scored lower). */
+    deprioritized: QMemoryCategory[];
+    /** Confidence of scenario detection (0.0-1.0). */
+    confidence: number;
+}
+/** Known query scenarios. */
+export type QueryScenario = "coding" | "config" | "conversation" | "learning" | "decision" | "general";
+/**
+ * Detect the query scenario and return category preferences.
+ *
+ * Uses pattern matching on the user query to infer intent.
+ * Returns "general" (no filtering) when confidence is below threshold.
+ *
+ * @param query - User query text
+ * @returns Category hint with preferred/deprioritized categories
+ */
+export declare function detectRecallCategories(query: string): RecallCategoryHint;
+/**
+ * Apply category boost/penalty to a recall score.
+ *
+ * Used by recall hooks to adjust memory scores based on category alignment.
+ *
+ * @param baseScore - Original relevance score (0.0-1.0)
+ * @param memoryCategory - Category of the memory entry (if known)
+ * @param hint - Category hint from detectRecallCategories()
+ * @returns Adjusted score
+ */
+export declare function applyCategoryBoost(baseScore: number, memoryCategory: string | undefined | null, hint: RecallCategoryHint): number;
+/**
+ * Filter and re-rank a list of recalled memories based on category preferences.
+ *
+ * @param memories - Raw recalled memories with optional category
+ * @param hint - Category hint from detectRecallCategories()
+ * @param minScore - Minimum adjusted score to keep (default: 0)
+ * @returns Re-ranked memories (highest adjusted score first)
+ */
+export declare function filterByCategory<T extends {
+    score?: number;
+    category?: string | null;
+}>(memories: T[], hint: RecallCategoryHint, minScore?: number): T[];
+/**
+ * Infer memory category from filename prefix convention.
+ * E.g. "lesson-docker.md" → "lesson", "fact-ports.md" → "fact"
+ *
+ * Exported for use by recall hooks.
+ */
+export declare function inferCategoryFromFilename(filename: string): QMemoryCategory | null;

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

@@ -3,7 +3,7 @@
  */
 export { PetSoulService, type PetSoul, type PetStats, type PetBreed } from "./pet-soul-service.js";
 export { maybeGenerateReaction, generateLLMReaction, type ReactionPool, type LLMReactionContext, type ReactionStyle } from "./pet-reaction-service.js";
-export { PetGrowthEngine, type GrowthEvent, type MoltResult, type PetAbility } from "./pet-growth-engine.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";

package/dist/types/runtime/pet/pet-growth-engine.d.ts

@@ -1,23 +1,24 @@
 /**
- * PetGrowthEngine — handles pet leveling, molting (脱壳升级), and ability unlocks.
+ * PetGrowthEngine — handles pet leveling, molting, and display-trait unlocks.
  *
  * Design §13: Growth system
  * - XP curve: level * 100 (linear P0, polynomial later)
  * - Molting: every 5 levels triggers a "molt" event with visual upgrade
- * - Abilities: unlocked at specific levels
+ * - Display traits: unlocked at specific levels, presentation-only
  * - Stats growth: each level-up slightly boosts one stat
  */
 import type { PetStats, PetSoul } from "./pet-soul-service.js";
-export interface PetAbility {
+export interface PetDisplayTrait {
     id: string;
     name: string;
     description: string;
     unlockedAtLevel: number;
+    surface: "presentation";
 }
 export interface GrowthEvent {
-    type: "level_up" | "molt" | "ability_unlock";
+    type: "level_up" | "molt" | "display_trait_unlock";
     level: number;
-    ability?: PetAbility;
+    displayTrait?: PetDisplayTrait;
     moltStage?: number;
 }
 export interface MoltResult {
@@ -46,13 +47,13 @@ export declare class PetGrowthEngine {
      */
     static getMoltResult(stage: number, currentStats: PetStats): MoltResult;
     /**
-     * Get all unlocked abilities for a given level.
+     * Get all unlocked presentation traits for a given level.
      */
-    static getUnlockedAbilities(level: number): PetAbility[];
+    static getUnlockedDisplayTraits(level: number): PetDisplayTrait[];
     /**
-     * Get next upcoming ability.
+     * Get next upcoming presentation trait.
      */
-    static getNextAbility(level: number): PetAbility | null;
+    static getNextDisplayTrait(level: number): PetDisplayTrait | null;
     /**
      * XP gain rules for different events.
      */

package/dist/types/runtime/pet/pet-growth-engine.test.d.ts

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

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

@@ -31,10 +31,9 @@ export interface PetBreed {
     rarity: string;
 }
 export declare class PetSoulService {
-    private workspaceDir;
     private soul;
     private storagePath;
-    constructor(workspaceDir: string);
+    constructor(_workspaceDir: string, ownerUserId?: string);
     load(): PetSoul | null;
     hatch(userId: string, generateSoul?: (rarity: string, stats: PetStats) => Promise<{
         name: string;

package/dist/types/runtime/pet/pet-soul-service.test.d.ts

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

package/dist/types/runtime/ports/agent-execution-contracts.d.ts

@@ -0,0 +1,182 @@
+import type { HookRegistry } from "../../contracts/hooks.js";
+import type { ChatMessage as WireChatMessage, ToolDefinition as WireToolDefinition, WireTokenUsage } from "../../protocol/wire/index.js";
+export type ChatMessage = WireChatMessage;
+export type TokenUsage = WireTokenUsage;
+export interface ToolDefinition extends WireToolDefinition {
+    backfillObservableInput?: (input: Record<string, unknown>) => void;
+}
+export type TurnEvent = {
+    type: "start";
+    turnId: string;
+} | {
+    type: "delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "tool_call";
+    turnId: string;
+    callId: string;
+    name: string;
+    arguments: string;
+    inputSummary?: string;
+} | {
+    type: "end";
+    turnId: string;
+    content: string;
+    usage?: TokenUsage;
+    model?: string;
+    provider?: string;
+} | {
+    type: "error";
+    turnId: string;
+    error: string;
+    code?: string;
+    usage?: TokenUsage;
+} | {
+    type: "skill_instruction";
+    turnId: string;
+    instruction: unknown;
+} | {
+    type: "tool_result";
+    turnId: string;
+    callId: string;
+    name: string;
+    ok: boolean;
+    error?: string;
+    outputPreview?: string;
+    durationMs?: number;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    details?: Record<string, unknown>;
+} | {
+    type: "tool_blocked";
+    turnId: string;
+    callId: string;
+    name: string;
+    reason: string;
+} | {
+    type: "recovery";
+    turnId: string;
+    action: string;
+    detail?: string;
+} | {
+    type: "plan_update";
+    turnId: string;
+    slug: string;
+    content: string;
+} | {
+    type: "heartbeat";
+    turnId: string;
+    message: string;
+} | {
+    type: "tool_use_summary";
+    turnId: string;
+    summary: string;
+} | {
+    type: "reasoning_delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "suggestions";
+    turnId: string;
+    items: Array<{
+        text: string;
+        icon?: string;
+        action?: string;
+    }>;
+} | {
+    type: "media_result";
+    turnId: string;
+    mediaType: "image" | "tts" | "video" | "music";
+    url: string;
+    model?: string;
+    provider?: string;
+    durationSeconds?: number;
+    width?: number;
+    height?: number;
+    mimeType?: string;
+    billingUnit?: string;
+    billingQuantity?: number;
+    taskId?: string;
+} | {
+    type: "artifact";
+    turnId: string;
+    artifactId: string;
+    artifactType: "code" | "file" | "image" | "document" | "diagram" | "table";
+    title: string;
+    filePath?: string;
+    language?: string;
+    content?: string;
+    mimeType?: string;
+} | {
+    type: "annotations";
+    turnId: string;
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "subagent_started";
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    prompt?: string;
+} | {
+    type: "subagent_ended";
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    ok: boolean;
+    outputPreview?: string;
+    error?: string;
+};
+export interface ToolInvoker {
+    invoke(turnId: string, name: string, args: string, signal?: AbortSignal): Promise<{
+        result: string;
+        error?: string;
+        toolReferences?: string[];
+        imageUrls?: string[];
+        details?: Record<string, unknown>;
+    }>;
+}
+export interface AgentRunRequest {
+    turnId: string;
+    sessionId: string;
+    messages: ChatMessage[];
+    tools: ToolDefinition[];
+    systemPrompt?: string;
+    config?: {
+        model?: string;
+        apiKey?: string;
+        temperature?: number;
+        maxOutputTokens?: number;
+        parentDepth?: number;
+    };
+}
+export interface ForkedAgentRunner {
+    run(request: AgentRunRequest, signal?: AbortSignal): AsyncIterable<TurnEvent>;
+}
+export interface ForkedAgentRunnerFactory {
+    (params: {
+        transport: unknown;
+        apiKey: string;
+        toolInvoker: ToolInvoker;
+        log: AgentLogger;
+        hooks?: HookRegistry;
+        maxRounds?: number;
+    }): ForkedAgentRunner;
+}
+export interface AgentLogger {
+    info(message: string): void;
+    info(obj: Record<string, unknown>, message: string): void;
+    warn(message: string): void;
+    warn(obj: Record<string, unknown>, message: string): void;
+    error(message: string): void;
+    error(obj: Record<string, unknown>, message: string): void;
+    debug(message: string): void;
+    debug(obj: Record<string, unknown>, message: string): void;
+}
+export type { HookRegistry };

package/dist/types/runtime/ports/checkpoint-contracts.d.ts

@@ -0,0 +1,19 @@
+export interface Checkpoint {
+    id: string;
+    message: string;
+    timestamp: string;
+    fileCount: number;
+}
+export interface CheckpointResult {
+    success: boolean;
+    checkpoint?: Checkpoint;
+    checkpoints?: Checkpoint[];
+    diff?: string;
+    error?: string;
+}
+export interface CheckpointBackend {
+    createCheckpoint(message?: string): Promise<CheckpointResult>;
+    listCheckpoints(): Promise<CheckpointResult>;
+    restoreCheckpoint(checkpointId: string, paths?: string[]): Promise<CheckpointResult>;
+    diffCheckpoint(checkpointId: string): Promise<CheckpointResult>;
+}

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

@@ -0,0 +1,13 @@
+export type { MemoryWriter, MemoryWriteMetadata } from "./memory-writer.js";
+export type { MemoryRecallSource } from "./memory-recall-source.js";
+export type { MemoryProvider, MemorySearchOptions, MemorySearchResult, MemoryIngestMessage, MemoryIngestOptions, MemoryExtractionItem, MemoryConsolidationWriteResult, MemoryLearningSink, MemoryToolLocalProvider, MemoryActivitySummary, MemoryAtlasRecord, MemoryAtlasResult, MemoryUpdatePatch, MemoryHandlerProvider, MemoryDreamProvider, MemoryDecayProvider, MemoryRuntimeHookProvider, MemoryToolProvider, MemoryDreamRuntimeProvider, } from "./memory-provider.js";
+export type { PathService } from "./path-service.js";
+export { PERMISSION_MODES, } from "./permission-contracts.js";
+export type { ApprovalRequest, ApprovalResponse, PermissionApprovalResolver, PermissionBehavior, PermissionConfig, PermissionDecisionReason, PermissionMetadataResolver, PermissionMode, PermissionResult, PermissionRuleEnginePort, PermissionRuleEntry, PermissionUpdate, ToolPermissionCheckInput, } from "./permission-contracts.js";
+export type { ProjectMemoryFileInfo, ProjectMemoryResult, ProjectMemoryStore, ProjectMemoryStoreFactory, } from "./project-memory-store.js";
+export type { ToolBootstrap, ToolCatalog } from "./tool-contracts.js";
+export type { Checkpoint, CheckpointBackend, CheckpointResult } from "./checkpoint-contracts.js";
+export type { WorktreeBackend, WorktreeInfo, WorktreeResult } from "./worktree-contracts.js";
+export type { WebSearchBackend, WebSearchOutput, WebSearchResult } from "./web-search-contracts.js";
+export { buildToolResultMessage, type OpenAiToolCall, type ToolResultMessageInput } from "./tool-call-contracts.js";
+export type { AgentLogger, AgentRunRequest, ChatMessage, ForkedAgentRunner, ForkedAgentRunnerFactory, HookRegistry, TokenUsage, ToolDefinition, ToolInvoker, TurnEvent, } from "./agent-execution-contracts.js";

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

@@ -0,0 +1,146 @@
+import type { MemoryWriter } from "./memory-writer.js";
+export interface MemorySearchOptions {
+    limit?: number;
+    minScore?: number;
+    preferredCategories?: string[];
+    llmConfig?: unknown;
+}
+export interface MemorySearchResult {
+    blockId: string;
+    id?: string;
+    path?: string;
+    text: string;
+    content?: string;
+    score: number;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface MemoryIngestMessage {
+    role: string;
+    content: string;
+    timestamp?: number;
+}
+export interface MemoryIngestOptions {
+    llmConfig?: unknown;
+    source?: string;
+    sessionId?: string;
+}
+export interface MemoryExtractionItem {
+    text: string;
+    category?: string;
+    importance?: number;
+    confidence?: number;
+    source?: string;
+    event_date?: string;
+    tags?: string[];
+}
+export interface MemoryConsolidationWriteResult {
+    memoriesAdded?: number;
+    observationsAdded?: number;
+    proposalsAdded?: number;
+    claimsAdded?: number;
+    conflictsAdded?: number;
+    claimIds?: string[];
+    conflictIds?: string[];
+}
+export interface MemoryProvider {
+    readonly providerId: string;
+    search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    ingest?(messages: MemoryIngestMessage[], userId: string, options?: MemoryIngestOptions): Promise<void>;
+    addText?(text: string, userId: string, options?: MemoryIngestOptions): Promise<{
+        memoriesAdded: number;
+    }>;
+    remove?(memoryId: string): Promise<boolean>;
+}
+export interface MemoryLearningSink {
+    ingestExtracted(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
+}
+export interface MemoryToolLocalProvider {
+    addText(text: string, userId: string, metadata?: MemoryIngestOptions & {
+        category?: string;
+        importance?: number;
+    }): Promise<unknown>;
+    synthesizeTimeline(userId: string, startMs: number, endMs: number): string;
+    feedback(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+        affected: number;
+    }>;
+}
+export interface MemoryActivitySummary {
+    dailyCounts: Array<{
+        date: string;
+        count: number;
+    }>;
+    highlights: Array<{
+        text: string;
+        category: string;
+        importance: number;
+        date: string;
+    }>;
+}
+export interface MemoryAtlasRecord {
+    id: string;
+    text: string;
+    category?: string;
+    importance?: number;
+    confidence?: number;
+    source?: string;
+    sessionId?: string;
+    eventDate?: string;
+    tags?: string[];
+    createdAt?: string | number;
+    updatedAt?: string | number;
+    accessCount?: number;
+    lastAccessedAt?: string | number;
+    isArchived?: boolean;
+}
+export interface MemoryAtlasResult {
+    totalCount?: number;
+    records?: MemoryAtlasRecord[];
+    buckets?: unknown[];
+    clusters?: unknown[];
+    windowCursor?: unknown;
+    timeRange?: unknown;
+}
+export interface MemoryUpdatePatch {
+    text?: string;
+    category?: string;
+    importance?: number;
+    source?: string;
+    eventDate?: string;
+    tags?: string[];
+}
+export interface MemoryHandlerProvider extends MemoryProvider {
+    getAtlas?(userId: string, options?: Record<string, unknown>): MemoryAtlasResult;
+    getActivitySummary?(userId: string, days: number): MemoryActivitySummary;
+    observeExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
+    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>;
+}
+export interface MemoryDreamProvider {
+    search(query: string, userId: string, options?: {
+        limit?: number;
+    }): Promise<MemorySearchResult[]>;
+    proposeExtracted?(items: MemoryExtractionItem[], userId: string, options?: {
+        sessionId?: string;
+        source?: string;
+    }): Promise<{
+        proposalsAdded?: number;
+    }>;
+    feedback?(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+        affected: number;
+    }>;
+    getActivitySummary?(userId: string, days?: number): MemoryActivitySummary;
+    synthesizeTimeline?(userId: string, startMs: number, endMs: number): string;
+    getProfile?(userId: string, key: string): string | null;
+    setProfile?(userId: string, key: string, value: string): void;
+    getAllProfiles?(userId: string): Record<string, string>;
+}
+export interface MemoryDecayProvider {
+    triggerDecay(userId: string, maxAgeDays?: number): Promise<{
+        decayed: number;
+    }>;
+}
+export type MemoryRuntimeHookProvider = MemoryProvider & MemoryWriter;
+export type MemoryToolProvider = MemoryProvider & MemoryToolLocalProvider;
+export type MemoryDreamRuntimeProvider = MemoryDreamProvider & MemoryDecayProvider;

package/dist/types/runtime/ports/memory-recall-source.d.ts

@@ -0,0 +1,3 @@
+export interface MemoryRecallSource {
+    getRootPath(): string;
+}