qlogicagent 2.24.1 → 2.24.2

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -1,273 +0,0 @@
-/**
- * Dream Sub-agent — CC autoDream parity.
- *
- * Memory consolidation runs as a restricted sub-agent:
- *   - Read-only tool access (bash: ls/grep/cat/find/stat/wc/head/tail)
- *   - File writes restricted to memory directory
- *   - 4-phase system prompt: Orient → Gather → Consolidate → Prune
- *   - Trigger gates: time (24h) + session count (5)
- *   - PID-based consolidation lock
- *
- * Reference: claude-code src/services/autoDream/
- */
-import type { DreamTaskState, DreamTurn } from "../tasks/task-types.js";
-import type { ToolDefinition, ToolInvoker, AgentLogger, HookRegistry, ForkedAgentRunnerFactory } from "../ports/agent-execution-contracts.js";
-import type { LLMTransport } from "../ports/index.js";
-import type { TaskStore } from "../infra/task-runtime.js";
-export interface DreamTriggerConfig {
-    /** Minimum hours since last consolidation. Default: 24. */
-    minHours: number;
-    /** Minimum sessions since last consolidation. Default: 5. */
-    minSessions: number;
-    /** Minimum turns in current session as alternative gate. Default: 20. */
-    minTurnsInSession: number;
-    /** Scan throttle interval (ms). Default: 600_000 (10 min). */
-    scanIntervalMs: number;
-    /** Force run, ignoring gates. */
-    force?: boolean;
-}
-export interface DreamContext {
-    /** Root directory where memory files live. */
-    memoryRoot: string;
-    /** Directory containing session transcript JSONL files. */
-    transcriptDir: string;
-    /** Current agent session ID (excluded from session count). */
-    currentSessionId: string;
-    /** Callback to list session IDs touched since a timestamp. */
-    listSessionsSince: (sinceMs: number) => Promise<string[]>;
-    /** Turn count in current session (for single-session users). */
-    currentSessionTurnCount?: number;
-}
-export interface DreamToolRestriction {
-    toolName: string;
-    input: Record<string, unknown>;
-}
-export type DreamToolVerdict = {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: string;
-};
-/** Result of a dream consolidation run. */
-export interface DreamRunResult {
-    /** Whether dream ran successfully. */
-    ok: boolean;
-    /** Number of sessions reviewed. */
-    sessionsReviewed: number;
-    /** Memory files touched. */
-    filesTouched: string[];
-    /** Dream turns produced. */
-    turns: DreamTurn[];
-    /** Total duration (ms). */
-    durationMs: number;
-    /** Error message if failed. */
-    error?: string;
-}
-/**
- * Check if a tool invocation is allowed during dream consolidation.
- *
- * Allowed:
- *   - read_file, grep, glob, search — unrestricted read-only tools
- *   - bash — only read-only commands (ls, grep, cat, find, stat, wc, head, tail)
- *   - Host project_memory MCP tool — the sole project-memory writer
- *   - raw write/edit/patch — denied (project-memory writes stay Host-owned)
- *   - Everything else — denied
- */
-export declare function canUseDreamTool(memoryRoot: string, restriction: DreamToolRestriction): DreamToolVerdict;
-/**
- * Canonical catalog tool names advertised to the dream sub-agent. This trims the
- * full manifest (dozens of irrelevant tools) down to what dream actually uses.
- * Every name here MUST be allowed by canUseDreamTool — raw write/edit/patch are
- * intentionally absent (canUseDreamTool hard-denies them); Host project memory
- * is the sole sanctioned memdir writer.
- */
-export declare const DREAM_ALLOWED_TOOLS: Set<string>;
-/**
- * Build the 4-phase memory consolidation prompt.
- *
- * Adapted from CC's consolidationPrompt.ts with our project context.
- * P5: Enhanced with category-aware merge rules from write gate taxonomy.
- */
-export declare function buildConsolidationPrompt(memoryRoot: string, transcriptDir: string, sessionIds: string[], opts?: {
-    hasQMemory?: boolean;
-    categoryContext?: string;
-    temporalContext?: string;
-    profileContext?: string;
-    sessionDigest?: string;
-}): string;
-/**
- * Check whether dream consolidation should run.
- *
- * Gate order (cheapest first):
- *   1. Time gate — hours since lastConsolidatedAt >= minHours
- *   2. Scan throttle — 10-minute interval to suppress redundant scans
- *   3. Session gate — session count since lastConsolidatedAt >= minSessions
- *
- * @returns Session IDs to review, or null if gates failed.
- */
-export declare function shouldTriggerDream(ctx: DreamContext, config?: Partial<DreamTriggerConfig>): Promise<{
-    sessionIds: string[];
-} | null>;
-/**
- * Attempt to acquire the consolidation liveness lock.
- *
- * A held lock is "live" only if its mtime is fresh (< MAX_DREAM_RUN_MS) AND the
- * recorded PID is alive. A stale mtime reclaims unconditionally — this defends
- * against a crashed holder whose PID was reused by an unrelated process (the old
- * pure-PID check would falsely see it as alive and deadlock for up to an hour).
- *
- * @returns 0 on acquisition, or null if blocked by a live holder.
- */
-export declare function tryAcquireConsolidationLock(memoryRoot: string): Promise<number | null>;
-/**
- * Refresh the lock mtime so a long-but-legitimate dream is not reclaimed.
- * Called periodically by the dream runner. No-op if we no longer own the lock.
- */
-export declare function heartbeatConsolidationLock(memoryRoot: string): Promise<void>;
-/** Release the liveness lock explicitly (on failure, abort, or shutdown). */
-export declare function releaseConsolidationLock(memoryRoot: string): Promise<void>;
-/**
- * Rollback after a FAILED dream run: release the lock. The gate marker is NOT
- * touched (only success advances it), so a failed run never delays the next gate.
- * `_priorMtime` is retained for call-site compatibility and ignored.
- */
-export declare function rollbackConsolidationLock(memoryRoot: string, _priorMtime: number): Promise<void>;
-/**
- * Record a SUCCESSFUL consolidation: advance the gate marker (mtime = now) and
- * release the liveness lock.
- */
-export declare function markConsolidationComplete(memoryRoot: string): Promise<void>;
-/** Create initial DreamTaskState. */
-export declare function createDreamTaskState(opts: {
-    sessionId: string;
-    sessionsReviewing: number;
-    priorLockMtime: number;
-    parentTaskId?: string;
-}): DreamTaskState;
-/** Add a turn to the dream state. */
-export declare function addDreamTurn(state: DreamTaskState, turn: DreamTurn, touchedPaths: string[]): DreamTaskState;
-/** Mark dream as completed. */
-export declare function completeDreamState(state: DreamTaskState): DreamTaskState;
-/** Mark dream as failed. */
-export declare function failDreamState(state: DreamTaskState): DreamTaskState;
-/**
- * Full dream orchestration entry point.
- *
- * This coordinates the entire dream lifecycle:
- *   1. Check trigger gates
- *   2. Acquire consolidation lock
- *   3. Build consolidation prompt
- *   4. Return dream context for the caller to run through agent loop
- *
- * The caller (stdio-server) is responsible for:
- *   - Running the prompt through the agent's tool loop
- *   - Applying canUseDreamTool() restrictions via tool.before_invoke hook
- *   - Calling markConsolidationComplete() on success
- *   - Calling rollbackConsolidationLock() on failure
- */
-export declare function prepareDreamRun(ctx: DreamContext, config?: Partial<DreamTriggerConfig>): Promise<{
-    prompt: string;
-    taskState: DreamTaskState;
-    sessionIds: string[];
-} | null>;
-export interface DreamRunDeps {
-    /** Dream context (memoryRoot, transcriptDir, etc.) */
-    context: DreamContext;
-    /** Trigger configuration */
-    triggerConfig?: Partial<DreamTriggerConfig>;
-    /** LLM transport */
-    transport: LLMTransport;
-    /** Tool invoker */
-    toolInvoker: ToolInvoker;
-    /** Concrete agent runner factory injected by CLI/app layer. */
-    createAgentRunner: ForkedAgentRunnerFactory;
-    /** Available tools (will be filtered by canUseDreamTool) */
-    tools: ToolDefinition[];
-    /** Task store — when provided, the dream registers as a `dream` task (lifecycle visible to host + LLM). */
-    taskStore?: TaskStore;
-    /** API key */
-    apiKey: string;
-    /** Model for dream */
-    model: string;
-    /** Logger */
-    log: AgentLogger;
-    /** Hook registry */
-    hooks?: HookRegistry;
-    /** Parent abort signal */
-    parentSignal?: AbortSignal;
-    /**
-     * Memory provider — when provided, Dream Agent acts as the "hippocampus":
-     * reads existing long-term memories, writes classified session insights,
-     * and submits feedback on outdated/contradicted memories.
-     */
-    memoryProvider?: {
-        search(query: string, userId: string, options?: {
-            limit?: number;
-        }): Promise<Array<{
-            id: string;
-            content: string;
-            score: number;
-        }>>;
-        proposeExtracted?(items: Array<{
-            text: string;
-            category?: string;
-            importance?: number;
-        }>, userId: string, options?: {
-            sessionId?: string;
-            source?: string;
-        }): Promise<{
-            proposalsAdded?: number;
-        }>;
-        feedback?(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong", context?: {
-            sessionId?: string;
-            silent?: boolean;
-        }): Promise<{
-            affected: number;
-        }>;
-        /** Recent activity summary for temporal context injection into Dream.
-         * B3(X7)异步化:Host 契约方法(host 模式经 x/host.request 跨进程)。 */
-        getActivitySummary?(userId: string, days?: number): Promise<{
-            dailyCounts: Array<{
-                date: string;
-                count: number;
-            }>;
-            highlights: Array<{
-                text: string;
-                category: string;
-                importance: number;
-                date: string;
-            }>;
-        }>;
-        /** Synthesize a timeline narrative for a time range. B3(X7)异步化。 */
-        synthesizeTimeline?(userId: string, startMs: number, endMs: number): Promise<string>;
-        /** Get/set user profile entries. B3(X7):setProfile/getAllProfiles 异步化;getProfile 为本地同步读取。 */
-        getProfile?(userId: string, key: string): string | null;
-        setProfile?(userId: string, key: string, value: string): Promise<void>;
-        getAllProfiles?(userId: string): Promise<Record<string, string>>;
-        /** Drain consolidation backlog: resolve conflicts + promote corroborated pending claims. */
-        resolveConflicts?(userId: string, opts?: {
-            minEvidenceToPromote?: number;
-        }): Promise<{
-            conflictsResolved: number;
-            claimsPromoted: number;
-        }>;
-    };
-    /** User ID for memory operations. */
-    memoryUserId?: string;
-}
-/**
- * Run a complete dream consolidation using an isolated forked agent.
- *
- * CC parity: This uses runForkedAgent() for true isolation instead of
- * hook-based tool restriction on the shared agent loop. The dream runs
- * in its own message history with its own AbortController.
- *
- * Full lifecycle:
- *   1. Check trigger gates
- *   2. Acquire consolidation lock
- *   3. Build consolidation prompt
- *   4. Fork sub-agent with restricted tools
- *   5. Run to completion
- *   6. Mark consolidation complete (or rollback on failure)
- */
-export declare function runDream(deps: DreamRunDeps): Promise<DreamRunResult>;

package/dist/types/runtime/execution/dream-category-context.d.ts

@@ -1,47 +0,0 @@
-import type { LongTermMemoryCategory } from "../../host-contract/memory-category.js";
-/** A memory file with its inferred category and metadata. */
-export interface CategorizedMemoryFile {
-    filename: string;
-    category: LongTermMemoryCategory | "uncategorized";
-    /** First line description. */
-    description: string;
-    /** File size bytes. */
-    sizeBytes: number;
-    /** Count of entries/bullets in the file. */
-    entryCount: number;
-}
-/** Category statistics for the dream prompt. */
-export interface CategoryManifest {
-    /** Per-category file groups. */
-    categories: Record<string, CategorizedMemoryFile[]>;
-    /** Total files scanned. */
-    totalFiles: number;
-    /** Files that couldn't be classified. */
-    uncategorizedCount: number;
-}
-/**
- * Scan MEMDIR and classify all topic files by category.
- *
- * @param memoryRoot - The MEMDIR root directory
- * @returns Category manifest with grouped files
- */
-export declare function scanCategoryManifest(memoryRoot: string): Promise<CategoryManifest>;
-/**
- * Category-specific merge/conflict rules for the dream prompt.
- *
- * These rules tell the dream agent how to handle each category:
- * - facts: supersede (newer replaces older when same topic)
- * - lessons: accumulate (append new insights, don't delete old)
- * - preferences: overwrite (latest preference wins)
- * - patterns: merge (consolidate duplicates into one authoritative entry)
- * - decisions: update (add "update" section if decision changed)
- */
-export declare const CATEGORY_MERGE_RULES: Record<LongTermMemoryCategory | "uncategorized", string>;
-/**
- * Format the category manifest and merge rules as an injection block
- * for the dream consolidation prompt.
- *
- * This replaces the blind "grep transcripts" approach with structured
- * guidance about what exists and how to handle each category.
- */
-export declare function formatCategoryContextBlock(manifest: CategoryManifest): string;

package/dist/types/runtime/execution/memory-decay.d.ts

@@ -1,73 +0,0 @@
-/** Options for triggering a decay cycle. */
-export interface DecayOptions {
-    temporalExpiry?: boolean;
-    stalenessDecay?: boolean;
-    noiseArchival?: boolean;
-}
-/** Result of a decay cycle. */
-export interface DecayResult {
-    decayed: number;
-    archived: number;
-}
-export interface DecayConfig {
-    /** Minimum hours between decay cycles. Default: 24. */
-    minIntervalHours: number;
-    /** Enable temporal expiry (event/plan memories past grace period). Default: true. */
-    temporalExpiry: boolean;
-    /** Enable staleness decay (reduce importance of unaccessed memories). Default: true. */
-    stalenessDecay: boolean;
-    /** Enable noise archival (archive memories below threshold). Default: true. */
-    noiseArchival: boolean;
-}
-export declare const DEFAULT_DECAY_CONFIG: DecayConfig;
-/**
- * Check whether enough time has elapsed since last decay.
- * Returns true if decay should run.
- */
-export declare function shouldTriggerDecay(memoryRoot: string, config?: Partial<DecayConfig>): Promise<boolean>;
-/**
- * Mark decay as having just run (persist timestamp).
- */
-export declare function markDecayComplete(memoryRoot: string): Promise<void>;
-export interface DecayCycleDeps {
-    /** Memory provider with triggerDecay method. */
-    adapter: {
-        triggerDecay(userId: string): Promise<{
-            decayed: number;
-        }>;
-    };
-    /** User ID for memory operations. */
-    userId: string;
-    /** Memory root directory (for gate marker). */
-    memoryRoot: string;
-    /** Decay configuration overrides. */
-    config?: Partial<DecayConfig>;
-    /** Logger. */
-    log?: {
-        info(msg: string): void;
-        debug?(msg: string): void;
-    };
-}
-export interface DecayCycleResult {
-    /** Whether decay actually ran (false = skipped by gate OR failed — see `failed`). */
-    ran: boolean;
-    /** True when the cycle was ATTEMPTED and errored — distinguishes a failure from a cooldown skip. */
-    failed?: boolean;
-    /** Failure reason, present when failed=true. */
-    error?: string;
-    /** Number of memories whose importance was reduced. */
-    decayed: number;
-    /** Number of memories archived (below threshold). */
-    archived: number;
-    /** Duration in ms. */
-    durationMs: number;
-}
-/**
- * Run a full decay cycle with gate check.
- *
- * Lifecycle:
- *   1. Check time gate (24h default)
- *   2. Call the Host-backed memory provider
- *   3. Mark completion timestamp
- */
-export declare function runDecayCycle(deps: DecayCycleDeps): Promise<DecayCycleResult>;

package/dist/types/runtime/execution/turn-progress-notifier.d.ts

@@ -1,16 +0,0 @@
-/**
- * 长任务进度通知（IM 渠道体验）：IM 里看不到工具流，超过 minIntervalMs 的轮次
- * 以节流方式发 turn.progress，由 gateway/IM 桥接渲染成一条简短进度文本。
- * 桌面端 UI 已有工具流展示，gateway 可按渠道选择忽略此通知。
- */
-export interface TurnProgressNotifierOptions {
-    turnId: string;
-    send: (method: string, params: Record<string, unknown>) => void;
-    /** 两条进度通知的最小间隔；默认 10s。 */
-    minIntervalMs?: number;
-    now?: () => number;
-}
-export interface TurnProgressNotifier {
-    onToolResult(toolName: string): void;
-}
-export declare function createTurnProgressNotifier(options: TurnProgressNotifierOptions): TurnProgressNotifier;

package/dist/types/runtime/hooks/memory-hooks.d.ts

@@ -1,111 +0,0 @@
-import type { HookRegistry } from "../../contracts/hooks.js";
-import type { MemoryProvider } from "../ports/memory-provider.js";
-import type { MemoryExtractionQueue, MemoryWriter } from "../ports/memory-writer.js";
-import type { MemoryRecallSource } from "../ports/memory-recall-source.js";
-export declare const MEMORY_PREFETCH_CONFIG: {
-    readonly MAX_SESSION_BYTES: number;
-    readonly LIMIT_PER_RECALL: 10;
-    readonly MAX_SURFACED_ENTRIES: 100;
-};
-/**
- * Fallback for hosts that don't inject deps.procedureTag. MUST stay equal to
- * skills/memory/task-distillation PROCEDURE_TAG (runtime cannot import skills
- * per the architecture boundary; task-distillation.test.ts asserts equality).
- */
-export interface MemoryHooksDeps {
-    /** QMemory adapter (MemoryProvider with search/health). */
-    memoryProvider?: MemoryProvider;
-    /** Local memory provider for direct writes (auto-extract). */
-    localMemoryProvider?: MemoryWriter;
-    /** Host-owned durable hand-off for completed turns awaiting semantic extraction. */
-    memoryExtractionQueue?: MemoryExtractionQueue;
-    /** User ID for memory lookups. */
-    userId: string;
-    /** Logger. */
-    log: {
-        debug(msg: string): void;
-        warn(msg: string): void;
-    };
-    /** Access to recent messages (for auto-extract). Set externally per turn. */
-    getLastUserMessage?: () => string | undefined;
-    /** Access to last assistant response (for implicit extraction). Set externally per turn. */
-    getLastAssistantMessage?: () => string | undefined;
-    /** Background LLM for implicit extraction. If provided, enables Layer 2. */
-    llmExtract?: (prompt: string, signal?: AbortSignal) => Promise<string | null>;
-    /** Shared process lane: queues learning work and aborts it for foreground turns. */
-    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
-    /** Part B write visibility: forwards turn.memory_written on auto-extract commits. */
-    sendNotification?: (method: string, params: Record<string, unknown>) => void;
-    /** V3.2 usage 仪表:procedure 复用的 session 维度与负反馈计数落盘目录。 */
-    /** Tag marking a distilled procedure memory. CLI injects it to preserve the runtime/skills boundary. */
-    procedureTag: string;
-    /** V3.2: record distilled procedures whose text reached the prompt (positive reuse signal). cli-injected.
-     * [A7] Called from memory.after_recall with the post-cap injected subset — NOT from
-     * before_recall: search hits the model never saw must not build promotion evidence. */
-    recordProcedureRecalls(procedureIds: string[], sessionId: string): void;
-    /** V3.2: record negative feedback against distilled procedures (failed turn). cli-injected. */
-    recordProcedureNegatives(procedureIds: string[]): void;
-    /** [A7] Host-side access ledger (memories.access_count/last_accessed_at): report the L2 ids
-     * actually injected this turn. cli-injected (fire-and-forget; Host stays the single writer —
-     * search() no longer counts hits, so skipping this call means the memory goes uncounted). */
-    recordInjectedAccess(memoryIds: string[], context: {
-        sessionId: string;
-        turnId: string;
-    }): void;
-    /** Host-owned recall outcome ledger. Best-effort accounting must never block a turn. */
-    recordRecallOutcome(input: {
-        sessionId: string;
-        turnId: string;
-        event: "used" | "helped" | "harmed" | "unattributed";
-    }): void;
-}
-/** Session-scoped state for dedup and byte budget (CC parity). */
-export interface MemoryPrefetchState {
-    /** Paths already surfaced this session (CC readFileState LRU parity). */
-    surfacedPaths: Set<string>;
-    /** Total bytes injected this session. */
-    sessionBytes: number;
-}
-/**
- * Create a fresh memory prefetch state (once per session).
- */
-export declare function createMemoryPrefetchState(): MemoryPrefetchState;
-/**
- * Register memory lifecycle hooks on the HookRegistry.
- *
- * Hook points wired:
- *   - memory.before_recall: prefetch context from qmemory (query-based); NO reuse
- *     accounting here ([A7]: retrieval hits the model never saw are not evidence)
- *   - memory.after_recall: reuse accounting off the post-cap injected ids + log
- *
- * CC parity additions:
- *   - Repeated L2 evidence remains available on every turn; surfacedPaths only
- *     prevents charging the unique-session byte budget twice for the same id
- *   - Unique session byte limit (MAX_SESSION_BYTES = 60KB)
- *   - Async prefetch (non-blocking promise, abort-aware)
- *
- * Returns a cleanup function to unregister.
- */
-export declare const RESIDENT_TAG_GROUPS: string[][];
-export declare function registerMemoryHooks(hooks: HookRegistry, deps: MemoryHooksDeps, 
-/** Shared statepass the same object across hook re-registrations in a session. */
-prefetchState?: MemoryPrefetchState): () => void;
-export interface MemdirRecallHookDeps {
-    /** Project memory recall source (lazy: may be null at registration time). */
-    getMemorySource: () => MemoryRecallSource | null;
-    /** Logger. */
-    log: {
-        debug(msg: string): void;
-        warn(msg: string): void;
-    };
-}
-/**
- * Register the MEMDIR cross-file recall hook on `memory.before_recall`.
- *
- * - Priority 40 (before QMemory at 50)
- * - Scans topic files, selects top-5 relevant
- * - Injects content into recalledMemories (merged with QMemory results)
- * - Respects session byte budget from shared MemoryPrefetchState
- * - Dedup via surfacedPaths (shared with QMemory hook)
- */
-export declare function registerMemdirRecallHook(hooks: HookRegistry, deps: MemdirRecallHookDeps, prefetchState?: MemoryPrefetchState): () => void;

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

@@ -1,31 +0,0 @@
-import type { AcpHostRequestHandler } from "./acp-protocol-adapter.js";
-interface HostHandlerOpts {
-    cwd: string;
-    /**
-     * Optional interactive permission resolver. When provided, session/request_permission is routed
-     * here (forwarded to the user) instead of auto-allowing. Returning a chosen optionId responds to
-     * the external agent. If omitted, permissions auto-allow (host-trust baseline for sub-agents).
-     */
-    requestPermission?: (params: Record<string, unknown>) => Promise<{
-        optionId: 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
- * (@agentclientprotocol/sdk):
- *   - createTerminal       -> { terminalId }
- *   - terminalOutput       -> { output, truncated, exitStatus: {exitCode, signal} | null }
- *   - waitForTerminalExit  -> { exitCode, signal }
- */
-export declare function createAcpHostHandler(opts: HostHandlerOpts): AcpHostRequestHandler & {
-    disposeAll(): void;
-};
-export {};