qlogicagent 1.3.0 → 2.1.0

package/dist/qlogicagent.cmd

@@ -0,0 +1,2 @@
+@echo off
+node "%~dp0cli.js" %*

package/dist/types/cli/main.d.ts

@@ -6,6 +6,10 @@
  * All log/debug output goes to stderr (never pollutes the protocol).
  *
  * Usage:
- *   qlogicagent [--verbose]
+ *   qlogicagent [--verbose] [--acp]
+ *
+ * Flags:
+ *   --verbose  Enable debug logging to stderr
+ *   --acp      Enable ACP (Agent-Client Protocol) server alongside legacy protocol
  */
 export {};

package/dist/types/cli/stdio-server.d.ts

@@ -9,6 +9,7 @@
  * The physical I/O layer is abstracted via the Transport interface.
  */
 import type { Transport } from "./transport.js";
+import { AcpServer } from "../transport/acp-server.js";
 export interface StdioServerConfig {
     verbose: boolean;
     transport?: Transport;
@@ -35,6 +36,8 @@ export declare class StdioServer {
     private currentTransport;
     private currentApiKey;
     private currentModel;
+    private currentProvider;
+    private currentBaseUrl;
     private sessionState;
     private currentMediaApiKeys;
     private taskStore;
@@ -43,6 +46,10 @@ export declare class StdioServer {
     /** QMemory adapter (when QMEMORY_BASE_URL env is set). Used by Dream hippocampus bridge. */
     private qmemoryAdapter;
     private qmemoryUserId;
+    /** MEMDIR file-based memory (CC memdir parity). */
+    private memdir;
+    /** Memory write gate state (P2+P3: category gate + supersedes). */
+    private memoryWriteState;
     private fileWatcher;
     /** Pending ask_user requests waiting for host response */
     private pendingAskUser;
@@ -59,6 +66,20 @@ export declare class StdioServer {
     /** Process managers for solo/product (stored for agents.processes/kill). */
     private soloProcessManager;
     private productProcessManager;
+    /** ACP Server instance — handles ACP protocol alongside legacy protocol. */
+    private acpServer;
+    /** Idle dream timer — fires after configurable idle period to trigger memory consolidation. */
+    private idleDreamTimer;
+    /** Idle dream config (minutes). Default: 30 min idle = trigger dream. */
+    private idleDreamMinutes;
+    /** Whether idle dream is enabled. Requires LLM config + memory root to be set. */
+    private idleDreamEnabled;
+    /** Last dream timestamp to enforce cooldown. */
+    private lastDreamAt;
+    /** Dream cooldown (ms). Default: 4 hours. */
+    private dreamCooldownMs;
+    /** Max dream duration (ms). Default: 5 minutes. */
+    private dreamMaxDurationMs;
     constructor(config: StdioServerConfig);
     start(): void;
     stop(): void;
@@ -104,15 +125,15 @@ export declare class StdioServer {
      */
     private handleSessionGetInfo;
     /**
-     * `memory.list` — Enumerate available memory sources (local store + qmemory).
+     * `memory.list` — Enumerate available memory sources (memdir + qmemory).
      */
     private handleMemoryList;
     /**
-     * `memory.read` — Read memory content from local store or QMemory.
+     * `memory.read` — Read memory content from memdir (INDEX.md or topic file).
      */
     private handleMemoryRead;
     /**
-     * `memory.write` — Write memory content to local store (agent notes / user profile).
+     * `memory.write` — Write memory content to memdir (INDEX.md or topic file).
      */
     private handleMemoryWrite;
     /**
@@ -157,12 +178,11 @@ export declare class StdioServer {
      */
     private handleTodosList;
     /**
-     * `memory.search` — Vector search via QMemory adapter.
-     * Powers the memory page's search feature.
+     * `memory.search` — Search memory via QMemory (vector) or memdir (local keyword).
      */
     private handleMemorySearch;
     /**
-     * `memory.delete` — Remove a memory entry by substring match (local) or ID (qmemory).
+     * `memory.delete` — Remove memory entry from memdir (INDEX.md line) or QMemory (by ID).
      */
     private handleMemoryDelete;
     /**
@@ -243,4 +263,40 @@ export declare class StdioServer {
     private sendNotification;
     private writeStdout;
     private log;
+    /**
+     * Enable idle dream scheduling. Called after session setup when LLM config is available.
+     */
+    enableIdleDream(minutes?: number): void;
+    private resetIdleDreamTimer;
+    private cancelIdleDreamTimer;
+    private triggerIdleDream;
+    /**
+     * Initialize the ACP server alongside the legacy protocol.
+     * Called once when the host is an ACP-compliant client.
+     */
+    initAcpServer(): void;
+    /** Get the ACP server instance (for external wiring, e.g., main.ts). */
+    getAcpServer(): AcpServer | null;
+    private acpHandleInitialize;
+    private acpHandleSessionNew;
+    private acpHandleSessionPrompt;
+    /**
+     * Run a turn in ACP mode — streams events via session/update, returns final result.
+     * This duplicates the core logic of handleTurn but returns a promise with the final content.
+     */
+    private runAcpTurn;
+    private acpHandleSessionEnd;
+    private acpHandleSessionSetConfig;
+    private acpHandleSessionSetModel;
+    private acpHandleSessionSetMode;
+    private acpHandlePermissionResponse;
+    private acpHandleAbort;
+    private acpHandleDream;
+    private acpHandleSoloStart;
+    private acpHandleSoloStatus;
+    private acpHandleSoloSelect;
+    private acpHandleProductCreate;
+    private acpHandleProductResume;
+    private acpHandleProductStatus;
+    private acpHandleTeamDelegate;
 }

package/dist/types/contracts/hooks.d.ts

@@ -114,7 +114,10 @@ export interface HookContextMap {
         recalledMemories?: Array<{
             text: string;
             score?: number;
+            category?: string | null;
         }>;
+        preferredCategories?: string[];
+        deprioritizedCategories?: string[];
     };
     "memory.after_recall": HookTurnContext & {
         blockCount?: number;

package/dist/types/index.d.ts

@@ -10,7 +10,7 @@ export type { AgentConfig } from "./config/config.js";
 export type { Transport } from "./cli/transport.js";
 export { StdioTransport } from "./cli/transport.js";
 export { StdioServer, type StdioServerConfig } from "./cli/stdio-server.js";
-export { ProviderRegistry, createLLMClient, autoDetectProvider, } from "./llm/index.js";
+export { ProviderRegistry, createLLMClient, } from "./llm/index.js";
 export type { LLMTransport, LLMRequest, LLMChunk } from "./llm/index.js";
 export { createHookRegistry } from "./runtime/hooks/hook-registry.js";
 export { buildSkillInstruction, } from "./orchestration/index.js";

package/dist/types/llm/index.d.ts

@@ -12,7 +12,7 @@ export { ProviderRegistry } from "./provider-registry.js";
 export { BUILTIN_PROVIDERS } from "./builtin-providers.js";
 export { ModelCatalog } from "./model-catalog.js";
 export type { LLMClientConfig, LLMClient } from "./llm-client.js";
-export { createLLMClient, autoDetectProvider } from "./llm-client.js";
+export { createLLMClient } from "./llm-client.js";
 export { OpenAIChatTransport } from "./transports/openai-chat.js";
 export { AnthropicMessagesTransport } from "./transports/anthropic-messages.js";
 export { GeminiGenerateContentTransport } from "./transports/gemini-generatecontent.js";

package/dist/types/llm/transports/media-resolve.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Media URL Resolution — converts local/private URLs to inline base64 data URLs.
+ *
+ * Cloud LLM APIs (OpenAI, Anthropic, DeepSeek) cannot fetch content from
+ * localhost or private networks. This utility detects such URLs and resolves
+ * them to base64 data URLs that can be sent inline.
+ *
+ * URL-first design: the gateway stores media as HTTP URLs; this layer handles
+ * the last-mile transformation before sending to provider APIs.
+ */
+/** Check if a URL points to a local/private address that cloud APIs cannot reach. */
+export declare function isLocalUrl(url: string): boolean;
+/**
+ * Resolve a URL to a base64 data URL if it's a local address.
+ * Public URLs are returned as-is (the LLM API can fetch them directly).
+ *
+ * Returns the original URL for non-local addresses.
+ * Returns a `data:<mime>;base64,...` string for local addresses.
+ */
+export declare function resolveMediaUrl(url: string, fallbackMime?: string): Promise<string>;
+/**
+ * Batch-resolve multiple URLs. Returns array in same order.
+ * Failures are logged and the original URL is kept (best-effort).
+ */
+export declare function resolveMediaUrls(urls: string[], fallbackMime?: string): Promise<string[]>;

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

@@ -72,9 +72,11 @@ export declare function canUseDreamTool(memoryRoot: string, restriction: DreamTo
  * 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;
 }): string;
 /**
  * Check whether dream consolidation should run.

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

@@ -0,0 +1,47 @@
+import type { QMemoryCategory } from "../../skills/memory/memory-write-gate.js";
+/** A memory file with its inferred category and metadata. */
+export interface CategorizedMemoryFile {
+    filename: string;
+    category: QMemoryCategory | "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<QMemoryCategory | "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/dream-category-context.test.d.ts

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

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

@@ -3,4 +3,5 @@ export { createContentReplacementState, enforceToolResultBudget, maybePersistLar
 export { resolveToolEligibility, type ToolEligibilityContext, type ToolEligibilityResult } from "./tool-eligibility.js";
 export { runForkedAgent, type ForkedAgentParams, type CanUseToolFn } from "./forked-agent.js";
 export { runDream, type DreamRunDeps } from "./dream-agent.js";
+export { runDecayCycle, shouldTriggerDecay, markDecayComplete, type DecayCycleDeps, type DecayCycleResult, type DecayConfig } from "./memory-decay.js";
 export { createProgressTracker, updateProgressFromUsage, recordToolUse, getProgressUpdate, type AgentProgress, } from "./progress-tracker.js";

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

@@ -0,0 +1,57 @@
+import type { DecayOptions, DecayResult } from "../../skills/memory/qmemory-adapter.js";
+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 {
+    /** QMemory adapter with triggerDecay method. */
+    adapter: {
+        triggerDecay(userId: string, options?: DecayOptions): Promise<DecayResult>;
+    };
+    /** User ID for QMemory 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). */
+    ran: boolean;
+    /** 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 QMemory /v1/admin/decay
+ *   3. Mark completion timestamp
+ */
+export declare function runDecayCycle(deps: DecayCycleDeps): Promise<DecayCycleResult>;

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

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

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

@@ -1,3 +1,4 @@
 export { createHookRegistry, type RuntimeLogger } from "./hook-registry.js";
 export { registerMemoryHooks, createMemoryPrefetchState, type MemoryHooksDeps, type MemoryPrefetchState, MEMORY_PREFETCH_CONFIG, } from "./memory-hooks.js";
 export { registerContextCompressionHook, compressMessages } from "./context-compression.js";
+export { registerSkillRecallHooks, detectRetrospectiveTrigger, invalidateSkillRecallCache, type SkillRecallHooksDeps, SKILL_RECALL_CONFIG, } from "./skill-recall-hooks.js";

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

@@ -1,5 +1,6 @@
 import type { HookRegistry } from "../../contracts/hooks.js";
 import type { MemoryProvider } from "qlogicagent-runtime-contracts";
+import type { Memdir } from "../../skills/memory/memdir.js";
 export declare const MEMORY_PREFETCH_CONFIG: {
     /** Max bytes of memory content to inject per session (CC: 60KB) */
     readonly MAX_SESSION_BYTES: number;
@@ -47,3 +48,22 @@ export declare function createMemoryPrefetchState(): MemoryPrefetchState;
 export declare function registerMemoryHooks(hooks: HookRegistry, deps: MemoryHooksDeps, 
 /** Shared state — pass the same object across hook re-registrations in a session. */
 prefetchState?: MemoryPrefetchState): () => void;
+export interface MemdirRecallHookDeps {
+    /** MEMDIR instance (lazy: may be null at registration time). */
+    getMemdir: () => Memdir | 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/hooks/skill-recall-hooks.d.ts

@@ -0,0 +1,36 @@
+import type { HookRegistry } from "../../contracts/hooks.js";
+export declare const SKILL_RECALL_CONFIG: {
+    /** Max number of cross-project skills to inject per turn. */
+    readonly MAX_RECALLED_SKILLS: 3;
+    /** Max chars of skill content to include in recall context. */
+    readonly MAX_SKILL_CONTENT_CHARS: 800;
+    /** Cache TTL for known project skill index (ms). */
+    readonly CACHE_TTL_MS: number;
+};
+/**
+ * Detect whether user message contains retrospective/cross-reference semantics.
+ * Returns extracted keywords for skill matching if triggered, or null.
+ */
+export declare function detectRetrospectiveTrigger(message: string): string[] | null;
+export interface SkillRecallHooksDeps {
+    /** Current project cwd (to exclude from cross-project search). */
+    currentCwd?: string;
+    /** Logger. */
+    log: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/**
+ * Register the cross-project skill recall hook on `memory.before_recall`.
+ * Runs at lower priority (60) than QMemory prefetch (50) so it supplements,
+ * not replaces, the standard memory recall.
+ *
+ * When triggered, injects cross-project skill metadata into recalledMemories.
+ */
+export declare function registerSkillRecallHooks(hooks: HookRegistry, deps: SkillRecallHooksDeps): () => void;
+/**
+ * Invalidate the cross-project skill index cache.
+ * Call when skills are created/deleted/promoted to refresh.
+ */
+export declare function invalidateSkillRecallCache(): void;

package/dist/types/runtime/infra/acp-protocol-adapter.d.ts

@@ -2,17 +2,54 @@
  * ACP Protocol Adapter — translates between qlogicagent's internal JSON-RPC
  * protocol and the ACP (Agent-Client Protocol) wire format.
  *
- * ACP = JSON-RPC 2.0 over stdio with different method names:
- *   initialize → initialize (compatible)
- *   session/new → create session with workspaceRoot + mcpServers
- *   prompt → send task
- *   session/close → abort
- *   message notifications → turn.delta / turn.end
+ * Aligned with @agentclientprotocol/sdk v0.18.2 (PROTOCOL_VERSION = 1).
+ * Reference: AionUI ClientSideConnection, @agentclientprotocol/sdk.
  *
- * Reference: AionUI AcpAgentManager, ACP protocol spec.
+ * ACP = JSON-RPC 2.0 over NDJSON stdio:
+ *   HOST → AGENT (requests):
+ *     initialize, session/new, session/prompt, session/close, session/resume
+ *   AGENT → HOST (notifications):
+ *     session/update — carries { sessionId, update: { sessionUpdate: "...", ...payload } }
+ *   AGENT → HOST (requests, host must respond):
+ *     fs/read_text_file, fs/write_text_file, session/request_permission,
+ *     session/elicitation, terminal/create, terminal/output, terminal/release,
+ *     terminal/wait_for_exit, terminal/kill
  */
 import type { ChildProcess } from "node:child_process";
 import type { AcpInitializeResult, AcpSessionResult, AcpPromptResponse, McpServerConfig } from "./acp-types.js";
+/**
+ * Handler for agent→host requests (fs, terminal, permission, elicitation).
+ * Host implementations should implement the methods they support.
+ */
+export interface AcpHostRequestHandler {
+    /** Read a text file from the host filesystem. */
+    readTextFile?(params: {
+        path: string;
+    }): Promise<{
+        content: string;
+    } | undefined>;
+    /** Write a text file on the host filesystem. */
+    writeTextFile?(params: {
+        path: string;
+        content: string;
+    }): Promise<Record<string, unknown> | undefined>;
+    /** Request permission for a tool call (return selected option). */
+    requestPermission?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Elicitation request (ask user for input). */
+    elicitation?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Create a terminal session. */
+    createTerminal?(params: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    /** Terminal output data. */
+    terminalOutput?(params: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    /** Release a terminal. */
+    releaseTerminal?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Wait for terminal exit. */
+    waitForTerminalExit?(params: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    /** Kill a terminal. */
+    killTerminal?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Extension method (unknown method from agent). */
+    extMethod?(method: string, params: unknown): Promise<unknown>;
+}
 /** Internal representation of an ACP notification translated to qlogicagent format. */
 export interface TranslatedNotification {
     method: string;
@@ -21,45 +58,59 @@ export interface TranslatedNotification {
 export declare class AcpProtocolAdapter {
     private pendingRpcs;
     private rl;
+    private child;
     private onNotification;
+    private hostHandler;
     /**
      * Attach to a child process's stdio for ACP communication.
      * Must be called before any RPC methods.
+     *
+     * @param child The spawned ACP agent process
+     * @param onNotification Callback for agent notifications (session/update, etc.)
+     * @param hostHandler Optional handler for agent→host requests (fs, terminal, permission)
+     */
+    attach(child: ChildProcess, onNotification?: (method: string, params: unknown) => void, hostHandler?: AcpHostRequestHandler): void;
+    /**
+     * Handle an incoming JSON-RPC request from the agent (reverse-RPC).
+     * Agent calls host for fs operations, terminal, permissions, etc.
      */
-    attach(child: ChildProcess, onNotification?: (method: string, params: unknown) => void): void;
+    private handleAgentRequest;
     /** Detach from the child process. */
     detach(): void;
     /** Send a raw JSON-RPC request and await response. */
     sendRpc(child: ChildProcess, method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
     /**
      * Perform ACP initialize handshake.
-     * Permissive: fallback protocolVersion to 0 if missing.
-     * Extracts `supportsResume` from capabilities for D-1 session resume.
+     * Sends standard clientInfo + clientCapabilities (aligned with SDK).
      */
     initialize(child: ChildProcess): Promise<AcpInitializeResult>;
     /**
      * Create an ACP session.
-     * Optionally injects MCP servers and system prompt.
+     * Official SDK params: { cwd, mcpServers, additionalDirectories? }
+     * Optionally injects system prompt as extension field.
      */
     createSession(child: ChildProcess, options: {
-        workspaceRoot: string;
+        cwd: string;
         mcpServers?: McpServerConfig[];
+        additionalDirectories?: string[];
         systemPrompt?: string;
     }): Promise<AcpSessionResult>;
     /**
      * Send a prompt to a running ACP session.
-     * Returns the complete response.
+     * Official SDK params: { sessionId, prompt: ContentBlock[], messageId? }
+     * Official SDK response: { stopReason, usage?, userMessageId? }
+     *
+     * Note: Actual content is delivered via session/update notifications DURING
+     * the prompt execution. The response only signals completion.
      */
     sendPrompt(child: ChildProcess, sessionId: string, content: string, timeoutMs?: number): Promise<AcpPromptResponse>;
     /**
-     * Resume an existing ACP session (D-1).
-     * Only call if the agent's capabilities.supportsResume is true.
-     * Falls back to createSession + summary injection if session/resume fails.
+     * Resume an existing ACP session (loadSession capability).
+     * Official SDK method: session/load (same schema as session/new + sessionId).
      */
     resumeSession(child: ChildProcess, sessionId: string, options?: {
-        workspaceRoot?: string;
+        cwd?: string;
         mcpServers?: McpServerConfig[];
-        summary?: string;
     }): Promise<AcpSessionResult>;
     /**
      * Close an ACP session.
@@ -68,6 +119,9 @@ export declare class AcpProtocolAdapter {
     /**
      * Translate an ACP notification into qlogicagent's internal format.
      * Returns null if the notification is not translatable (handled separately).
+     *
+     * Standard ACP: agent sends "session/update" notification with
+     *   params: { sessionId, update: { sessionUpdate: "<type>", ...payload } }
      */
     static translateNotification(method: string, params: unknown): TranslatedNotification | null;
 }

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

@@ -136,39 +136,52 @@ export interface AgentConfigStoreData {
 /** ACP initialize result (from agent's response). */
 export interface AcpInitializeResult {
     protocolVersion: number;
-    capabilities: {
-        prompts?: boolean;
-        /** Whether this agent supports session/resume (D-1). */
-        supportsResume?: boolean;
+    /** Standard ACP agentCapabilities (official SDK field). */
+    agentCapabilities: {
+        loadSession?: boolean;
+        mcpCapabilities?: {
+            http?: boolean;
+            sse?: boolean;
+        };
+        promptCapabilities?: {
+            audio?: boolean;
+            embeddedContext?: boolean;
+            image?: boolean;
+        };
+        sessionCapabilities?: Record<string, unknown>;
         [key: string]: unknown;
     };
-    serverInfo?: {
+    /** Standard ACP agentInfo (official SDK field). */
+    agentInfo?: {
         name: string;
         version?: string;
     };
+    authMethods?: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
 }
-/** ACP session/new result. */
+/** ACP session/new result (official: { sessionId, configOptions?, models?, modes? }). */
 export interface AcpSessionResult {
-    id: string;
+    sessionId: string;
 }
-/** ACP prompt response content item. */
-export interface AcpContentItem {
-    type: "text" | "image" | "resource";
-    text?: string;
-    data?: string;
-    mimeType?: string;
-}
-/** ACP prompt response. */
+/** Standard ACP stopReason. */
+export type AcpStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
+/** ACP prompt response (official: { stopReason, usage?, userMessageId? }). */
 export interface AcpPromptResponse {
-    content: AcpContentItem[];
+    stopReason: AcpStopReason;
     usage?: AcpPromptResponseUsage;
+    userMessageId?: string;
+    /** Aggregated text from session/update notifications (populated by adapter). */
+    text?: string;
 }
-/** ACP per-turn usage stats. */
+/** ACP per-turn usage stats (aligned with SDK zUsage). */
 export interface AcpPromptResponseUsage {
     inputTokens?: number;
     outputTokens?: number;
     totalTokens?: number;
     cachedReadTokens?: number;
+    cachedWriteTokens?: number;
     thoughtTokens?: number;
 }
 /** ACP usage_update notification payload (session-level). */

package/dist/types/runtime/infra/agent-paths.d.ts

@@ -7,7 +7,7 @@
  */
 /** Dot-directory name used for both user-level and project-level storage. */
 export declare const AGENT_DOT_DIR = ".qlogicagent";
-/** `~/.qlogicagent/` */
+/** `~/.qlogicagent/` (or QLOGICAGENT_HOME override) */
 export declare function getUserAgentHome(): string;
 /** `~/.qlogicagent/sessions/` */
 export declare function getUserSessionsRoot(): string;
@@ -59,7 +59,19 @@ export declare function getProjectSessionsRoot(cwd: string): string;
 export declare function getProjectSessionDir(cwd: string, sessionId: string): string;
 /** `<cwd>/.qlogicagent/checkpoints/` or `<cwd>/.qlogicagent/checkpoints/{sessionId}` */
 export declare function getProjectCheckpointsDir(cwd: string, sessionId?: string): string;
-/** `<cwd>/.qlogicagent/memory.json` */
-export declare function getProjectMemoryPath(cwd: string): string;
 /** `<gitRoot>/.qlogicagent/hooks/` */
 export declare function getGitRootHooksDir(gitRoot: string): string;
+/**
+ * Discover all known project directories from session history.
+ * Scans `~/.qlogicagent/sessions/` metadata to extract unique `cwd` paths.
+ * Used for cross-project skill recall (read-only, never writes to foreign projects).
+ *
+ * @param excludeCwd - Current project cwd to exclude from results
+ * @returns Array of absolute paths to project roots that have been worked on
+ */
+export declare function getKnownProjectDirs(excludeCwd?: string): string[];
+/**
+ * Get skill directories from all known projects (excluding current).
+ * Returns paths to `<project>/.qlogicagent/skills/` for recall-only access.
+ */
+export declare function getAllProjectSkillDirs(excludeCwd?: string): string[];