qlogicagent 2.10.22 → 2.10.24

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

@@ -0,0 +1,21 @@
+export interface MemoryWriteMetadata {
+    source?: string;
+    category?: string;
+    importance?: number;
+    eventDate?: string;
+    [key: string]: unknown;
+}
+export interface MemoryWriter {
+    addText(text: string, userId: string, metadata?: MemoryWriteMetadata): Promise<unknown>;
+    proposeExtracted?(items: Array<{
+        text: string;
+        category?: string;
+        importance?: number;
+    }>, userId: string, metadata?: MemoryWriteMetadata): Promise<{
+        proposalsAdded?: number;
+    }>;
+    findRelatedEvents?(text: string, userId: string): Promise<Array<{
+        id: string;
+    }>>;
+    feedback?(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<unknown>;
+}

package/dist/types/runtime/ports/path-service.d.ts

@@ -0,0 +1,5 @@
+export interface PathService {
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(dir: string): void;
+    resolveProjectDir(projectId?: string): string | undefined;
+}

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

@@ -0,0 +1,107 @@
+export type PermissionMode = "default" | "bypassPermissions" | "acceptEdits" | "dontAsk" | "plan" | "auto";
+export declare const PERMISSION_MODES: readonly PermissionMode[];
+export type PermissionBehavior = "allow" | "deny" | "ask";
+export interface PermissionRuleEntry {
+    pattern: string;
+    behavior: PermissionBehavior;
+    reason?: string;
+    source?: string;
+}
+export type PermissionDecisionReason = {
+    type: "rule";
+    rule: PermissionRuleEntry;
+} | {
+    type: "mode";
+    mode: PermissionMode;
+} | {
+    type: "hook";
+    hookName: string;
+    reason: string;
+} | {
+    type: "classifier";
+    classifier: string;
+    reason: string;
+} | {
+    type: "tool_check";
+    reason: string;
+} | {
+    type: "eligibility";
+    reasonCodes: string[];
+} | {
+    type: "sandbox";
+    reason: string;
+} | {
+    type: "other";
+    reason: string;
+};
+export interface PermissionAllowResult {
+    behavior: "allow";
+    updatedInput?: Record<string, unknown>;
+    decisionReason?: PermissionDecisionReason;
+}
+export interface PermissionAskResult {
+    behavior: "ask";
+    message: string;
+    toolName: string;
+    input?: Record<string, unknown>;
+    suggestions?: PermissionUpdate[];
+    decisionReason?: PermissionDecisionReason;
+}
+export interface PermissionDenyResult {
+    behavior: "deny";
+    message: string;
+    decisionReason: PermissionDecisionReason;
+}
+export type PermissionResult = PermissionAllowResult | PermissionAskResult | PermissionDenyResult;
+export interface PermissionUpdate {
+    pattern: string;
+    behavior: PermissionBehavior;
+    scope?: "session" | "persistent";
+    description?: string;
+}
+export interface PermissionConfig {
+    mode: PermissionMode;
+    rules: PermissionRuleEntry[];
+    defaultBehavior: PermissionBehavior;
+}
+export interface ToolPermissionCheckInput {
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    meta?: {
+        isReadOnly?: boolean;
+        isDangerous?: boolean;
+        requiresApproval?: boolean;
+        parallelSafe?: boolean;
+    };
+}
+export interface ApprovalRequest {
+    approvalId: string;
+    callId: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    message: string;
+    suggestions?: PermissionUpdate[];
+}
+export interface ApprovalResponse {
+    approvalId: string;
+    decision: "approved" | "denied";
+    updatedInput?: Record<string, unknown>;
+    permissionUpdate?: PermissionUpdate;
+}
+export interface PermissionRuleEnginePort {
+    setMode(mode: PermissionMode): void;
+    replaceRules(rules: PermissionRuleEntry[]): void;
+    setDefaultBehavior(behavior: PermissionBehavior): void;
+}
+export interface PermissionApprovalResolver {
+    resolveApproval(response: ApprovalResponse): void;
+}
+export interface PermissionMetadataResolver extends PermissionApprovalResolver {
+    setToolMeta?(tools: Array<{
+        function: {
+            name: string;
+        };
+        meta?: ToolPermissionCheckInput["meta"];
+    }>): void;
+    ruleEngineRef?: PermissionRuleEnginePort;
+}

package/dist/types/runtime/ports/project-memory-store.d.ts

@@ -0,0 +1,44 @@
+export interface ProjectMemoryFileInfo {
+    name: string;
+    size: number;
+    modifiedAt: string;
+    preview?: string;
+}
+export interface ProjectMemoryResult {
+    ok: boolean;
+    message: string;
+    file?: string;
+    indexUsage?: string;
+}
+export interface ProjectMemoryStore {
+    getRootPath(): string;
+    ensureInitialized(): void;
+    getIndexForPrompt(): string;
+    getIndexRaw(): string;
+    getIndexUsage(): {
+        chars: number;
+        lines: number;
+        percent: number;
+    };
+    addToIndex(content: string): Promise<ProjectMemoryResult>;
+    replaceInIndex(oldText: string, newText: string): Promise<ProjectMemoryResult>;
+    removeFromIndex(oldText: string): Promise<ProjectMemoryResult>;
+    createFile(name: string, content: string): Promise<ProjectMemoryResult>;
+    writeFile(name: string, content: string): Promise<ProjectMemoryResult>;
+    readFile(name: string): Promise<{
+        ok: boolean;
+        content?: string;
+        message: string;
+    }>;
+    deleteFile(name: string): Promise<ProjectMemoryResult>;
+    listFiles(): Promise<ProjectMemoryFileInfo[]>;
+    searchLocal(query: string): Promise<Array<{
+        file: string;
+        snippet: string;
+        score: number;
+    }>>;
+}
+export interface ProjectMemoryStoreFactory {
+    getRootPath(projectRoot: string): string;
+    create(projectRoot: string): ProjectMemoryStore;
+}

package/dist/types/runtime/ports/tool-call-contracts.d.ts

@@ -0,0 +1,16 @@
+export interface OpenAiToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolResultMessageInput {
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+    toolReferences?: string[];
+    imageUrls?: string[];
+}
+export declare function buildToolResultMessage(callId: string, result: ToolResultMessageInput): Record<string, unknown>;

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

@@ -0,0 +1,23 @@
+import type { ToolDefinition } from "../../protocol/wire/index.js";
+export interface RuntimeToolContract {
+    name: string;
+    label: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    isEnabled?: () => boolean;
+    shouldDefer?: boolean;
+    execute?(toolCallId: string, params: Record<string, unknown>, signal?: AbortSignal): Promise<{
+        content: Array<{
+            text?: string;
+        }>;
+    }>;
+}
+export interface ToolCatalog {
+    findTool(name: string): RuntimeToolContract | undefined;
+    getToolManifest(includeDeferred?: boolean): ToolDefinition[];
+    getToolNames(): string[];
+}
+export interface ToolBootstrap {
+    getAllBaseTools(): RuntimeToolContract[];
+    setWorkdir(dir: string): void;
+}

package/dist/types/runtime/ports/web-search-contracts.d.ts

@@ -0,0 +1,17 @@
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+export interface WebSearchOutput {
+    query: string;
+    results: WebSearchResult[];
+    totalResults?: number;
+}
+export interface WebSearchBackend {
+    search(query: string, options?: {
+        allowedDomains?: string[];
+        blockedDomains?: string[];
+        maxResults?: number;
+    }): Promise<WebSearchOutput>;
+}

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

@@ -0,0 +1,22 @@
+export interface WorktreeInfo {
+    name: string;
+    path: string;
+    branch: string;
+    isCurrent: boolean;
+    hasChanges: boolean;
+    unpushedCommits: number;
+}
+export interface WorktreeResult {
+    success: boolean;
+    worktree?: WorktreeInfo;
+    worktrees?: WorktreeInfo[];
+    previousCwd?: string;
+    error?: string;
+}
+export interface WorktreeBackend {
+    enterWorktree(name?: string): Promise<WorktreeResult>;
+    exitWorktree(action: "keep" | "remove", discardChanges?: boolean): Promise<WorktreeResult>;
+    listWorktrees(): Promise<WorktreeResult>;
+    isInWorktree(): boolean;
+    currentWorktree?(): WorktreeInfo | null;
+}

package/dist/types/runtime/prompt/environment-context.test.d.ts

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

package/dist/types/runtime/prompt/fresh-workspace-evidence.d.ts

@@ -0,0 +1,19 @@
+import { type SystemPromptSection } from "./system-prompt-sections.js";
+export interface PromptMessageLike {
+    role?: string;
+    content?: unknown;
+}
+export interface ToolNameLike {
+    function?: {
+        name?: string;
+    };
+    name?: string;
+}
+export interface FreshWorkspaceEvidencePolicy {
+    requiresFreshTool: boolean;
+    reason?: "file-read" | "file-mutation" | "memory-mutation" | "directory-list" | "content-search" | "shell" | "web";
+    allowedToolNames: string[];
+}
+export declare function getFreshWorkspaceEvidencePolicy(messages: readonly PromptMessageLike[] | string): FreshWorkspaceEvidencePolicy;
+export declare function selectFreshWorkspaceEvidenceTools<TTool extends ToolNameLike>(tools: readonly TTool[], policy: FreshWorkspaceEvidencePolicy): TTool[];
+export declare function createFreshWorkspaceEvidenceSection(policy: FreshWorkspaceEvidencePolicy): SystemPromptSection | null;

package/dist/types/runtime/prompt/fresh-workspace-evidence.test.d.ts

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

package/dist/types/runtime/prompt/instruction-loader.d.ts

@@ -29,6 +29,10 @@ export interface InstructionFileInfo {
     /** Glob patterns from frontmatter — file only applies when target path matches */
     globs?: string[];
 }
+export interface LiteralResponseRequirement {
+    marker: string;
+    placement: "prefix" | "suffix" | "include";
+}
 /**
  * Load all instruction files following CC's discovery order.
  *
@@ -49,15 +53,17 @@ export declare function loadInstructions(cwd: string, hooks?: HookRegistry): Pro
  * CC parity: getClaudeMds()
  */
 export declare function buildInstructionsPrompt(files: InstructionFileInfo[]): string;
+export declare function extractLiteralResponseRequirements(files: InstructionFileInfo[]): LiteralResponseRequirement[];
+export declare function applyLiteralResponseRequirements(content: string, requirements: readonly LiteralResponseRequirement[]): string;
 /**
  * Get conditional rules that match a target file path.
  * CC parity: getManagedAndUserConditionalRules() + getMemoryFilesForNestedDirectory()
  */
 export declare function getConditionalRules(cwd: string, targetPath: string): Promise<InstructionFileInfo[]>;
 /**
- * Load instructions with memoization.
- * CC parity: getMemoryFiles() with memoize.
- * Returns cached result if cwd hasn't changed.
+ * Load instructions for the current turn.
+ * This intentionally reloads from disk every call so instruction edits become
+ * visible on the next turn without depending on a filesystem watcher.
  */
 export declare function getInstructions(cwd: string, hooks?: HookRegistry): Promise<InstructionFileInfo[]>;
 /** Clear the instruction cache. Called after file changes or compaction. */

package/dist/types/runtime/prompt/instruction-loader.test.d.ts

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

package/dist/types/runtime/session/session-persistence.test.d.ts

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

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

@@ -0,0 +1,146 @@
+/**
+ * Task Type Taxonomy — CC-aligned sub-agent task state system.
+ *
+ * CC defines 7 task types for sub-agent dispatch. Each type has different:
+ *   - Execution model (in-process, subprocess, remote)
+ *   - Isolation level (shared, worktree, container)
+ *   - Permission handling (interactive, coordinator, worker)
+ *   - Tool access (full, restricted, read-only)
+ *
+ * Reference: claude-code src/tasks/types.ts
+ */
+/**
+ * The 7 task types from CC's sub-agent architecture.
+ *
+ * - local_bash: Subprocess shell execution (bash/powershell)
+ * - local_agent: Background forked Node process with its own tool loop
+ * - remote_agent: Cloud environment (polling-based, e.g., CCR sandbox)
+ * - in_process_teammate: Same process, AsyncLocalStorage-isolated agent
+ * - local_workflow: DAG/pipeline execution (planned)
+ * - monitor_mcp: MCP server monitoring agent (planned)
+ * - dream: Background memory consolidation agent
+ */
+export type TaskType = "local_bash" | "local_agent" | "remote_agent" | "in_process_teammate" | "local_workflow" | "monitor_mcp" | "dream";
+/**
+ * How a sub-agent is isolated from the parent execution.
+ *
+ * - shared: Same working directory, same filesystem (default fork)
+ * - worktree: Git worktree checkout — separate branch, merges back
+ * - container: Container sandbox (docker/remote)
+ */
+export type IsolationMode = "shared" | "worktree" | "container";
+/**
+ * Permission context for sub-agent execution.
+ * Determines which PermissionChecker variant is used.
+ *
+ * CC reference: 3 permission handler variants
+ * - interactive: User-facing agent, prompts for approval
+ * - coordinator: Orchestrator agent, auto-approves most non-destructive ops
+ * - worker: Headless worker, classifier-only (no user prompts)
+ */
+export type PermissionRole = "interactive" | "coordinator" | "worker";
+/** Common state fields shared by all task types. */
+export interface TaskStateBase {
+    /** Unique task ID. */
+    taskId: string;
+    /** Task type discriminant. */
+    type: TaskType;
+    /** Human-readable label. */
+    label: string;
+    /** The permission role for this task's agent. */
+    permissionRole: PermissionRole;
+    /** Isolation mode. */
+    isolation: IsolationMode;
+    /** Current lifecycle state. */
+    lifecycle: TaskLifecycle;
+    /** Parent task ID (for nested sub-agents). */
+    parentTaskId?: string;
+    /** Execution depth (0 = root). */
+    depth: number;
+    /** Maximum turns before forced stop. */
+    maxTurns: number;
+    /** Token budget for this task. */
+    tokenBudget: number;
+    /** Start timestamp (ms). */
+    startedAt: number;
+    /** End timestamp (ms), set when completed/failed. */
+    endedAt?: number;
+}
+export type TaskLifecycle = "pending" | "running" | "completed" | "failed" | "cancelled" | "timeout";
+/** Local bash task — subprocess shell execution. */
+export interface LocalBashTaskState extends TaskStateBase {
+    type: "local_bash";
+    command: string;
+    cwd: string;
+    pid?: number;
+}
+/** Local agent task — forked agent with its own tool loop. */
+export interface LocalAgentTaskState extends TaskStateBase {
+    type: "local_agent";
+    agentName: string;
+    systemPrompt: string;
+    /** Restricted tool set (empty = inherit parent). */
+    allowedTools: string[];
+    /** Worktree branch name (if isolation === "worktree"). */
+    worktreeBranch?: string;
+}
+/** Remote agent task — cloud sandbox execution. */
+export interface RemoteAgentTaskState extends TaskStateBase {
+    type: "remote_agent";
+    /** Remote session/environment ID. */
+    remoteSessionId: string;
+    /** Polling endpoint for status checks. */
+    pollEndpoint?: string;
+}
+/** In-process teammate — AsyncLocalStorage-isolated, same process. */
+export interface InProcessTeammateTaskState extends TaskStateBase {
+    type: "in_process_teammate";
+    teamName: string;
+    agentName: string;
+    /** Teammate's independent permission mode. */
+    permissionMode: string;
+    /** Async mailbox for coordinator ↔ worker communication. */
+    mailboxId?: string;
+    /** Isolated git worktree path for this teammate (CC team worktree parity). */
+    worktreePath?: string;
+    /** Worktree branch name (for cleanup). */
+    worktreeBranch?: string;
+}
+/** A single dream agent turn — text output + tool use count. */
+export interface DreamTurn {
+    text: string;
+    toolUseCount: number;
+}
+/** Dream phase lifecycle — CC alignment. */
+export type DreamPhase = "starting" | "updating" | "completed" | "failed";
+/** Dream task — background memory consolidation agent (CC autoDream parity). */
+export interface DreamTaskState extends TaskStateBase {
+    type: "dream";
+    sessionId: string;
+    /** Current dream phase. */
+    phase: DreamPhase;
+    /** Number of sessions being reviewed. */
+    sessionsReviewing: number;
+    /** Memory files touched by the dream agent. */
+    filesTouched: string[];
+    /** Dream agent turn history (capped). */
+    turns: DreamTurn[];
+    /** Stashed lock mtime for rollback on failure. */
+    priorLockMtime: number;
+}
+/** Placeholder for planned task types. */
+export interface PlannedTaskState extends TaskStateBase {
+    type: "local_workflow" | "monitor_mcp";
+}
+/** Union of all concrete task states. */
+export type TaskState = LocalBashTaskState | LocalAgentTaskState | RemoteAgentTaskState | InProcessTeammateTaskState | DreamTaskState | PlannedTaskState;
+/**
+ * Filter available tools by permission role.
+ *
+ * @param role - The agent's permission role
+ * @param availableTools - Full set of tool names
+ * @returns Filtered tool names appropriate for the role
+ */
+export declare function filterToolsByRole(role: PermissionRole, availableTools: string[]): string[];
+/** Create a new task state with defaults populated. */
+export declare function createTaskState(overrides: Pick<TaskStateBase, "taskId" | "type" | "label"> & Partial<TaskStateBase>): TaskStateBase;

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

@@ -95,8 +95,8 @@ export { parseFrontmatter, resolveSkillMetadata, resolveSkillInvocationPolicy, r
 export { loadSkillEntries, filterSkillEntries, buildSkillSnapshot, } from "./skill-system/skill-loader.js";
 export { scanSource, scanSkillDirectory, hasCriticalFindings, isScannable, } from "./skill-system/skill-guard.js";
 export type { SkillGuardDeps } from "./skill-system/skill-guard.js";
-export { installSkill, uninstallSkill, createEmptyLockfile, } from "./skill-system/skill-source.js";
-export type { TrustLevel, ScanVerdict, SkillSourceDescriptor, SkillFetchResult, SkillFetchDeps, SkillStorageDeps, SkillLockEntry, SkillLockfile, SkillInstallResult, } from "./skill-system/skill-source.js";
+export { trackSkillInvocation, getSkillStats, getAllSkillStats, resetStatsCache, } from "./skill-system/skill-source.js";
+export type { SkillStatsFile, SkillUsageStats, } from "./skill-system/skill-source.js";
 export { loadLifecycleStore, saveLifecycleStore, ensureRecord, recordInvocation, recordView, recordPatch, removeRecord, pinSkill, unpinSkill, runCurator, executeCuratorCycle, archiveSkillOnDisk, unarchiveSkillOnDisk, getSkillsByState, getLifecycleRecord, } from "./skill-system/skill-lifecycle.js";
 export type { SkillLifecycleState, SkillLifecycleRecord, SkillLifecycleStore, CuratorResult, } from "./skill-system/skill-lifecycle.js";
 export { validateSkillContent, generateSkillContent, autoFixFrontmatter, } from "./skill-system/skill-validation.js";

package/dist/types/skills/mcp/mcp-http-client.d.ts

@@ -1,8 +1,10 @@
 import type { PortableTool } from "../portable-tool.js";
+import { type McpToolAnnotations } from "./mcp-tool-metadata.js";
 interface McpToolSchema {
     name: string;
     description?: string;
     inputSchema?: Record<string, unknown>;
+    annotations?: McpToolAnnotations;
 }
 interface McpToolCallResult {
     content: Array<{

package/dist/types/skills/mcp/mcp-manager.d.ts

@@ -23,6 +23,8 @@ export interface McpServerEntry {
     args?: string[];
     /** Extra environment variables (stdio only) */
     env?: Record<string, string>;
+    /** Working directory for stdio MCP subprocesses */
+    cwd?: string;
     /** HTTP endpoint URL (http only) */
     url?: string;
     /** Extra HTTP headers (http only) */
@@ -38,11 +40,14 @@ export interface McpManagerConfig {
         info(msg: string): void;
         warn(msg: string): void;
     };
+    /** Active workspace boundary for local-path arguments passed into MCP tools. */
+    workspaceRoot?: string;
 }
 export declare class McpManager {
     private clients;
     private injected;
     private log;
+    private workspaceRoot?;
     constructor(config: McpManagerConfig);
     /**
      * Connect to all configured MCP servers. Failures are logged but don't block.
@@ -74,10 +79,8 @@ export declare class McpManager {
      * Read a resource from a specific MCP server by URI.
      */
     readResource(serverName: string, uri: string): Promise<McpResourceContent[]>;
+    private wrapToolsForWorkspaceBoundary;
     private reinjectTools;
 }
-/**
- * Parse MCP server configs from a JSON structure (mcp.json format).
- * Compatible with Claude Code's mcp_servers.json structure.
- */
+export declare function validateMcpToolWorkspaceBoundary(toolName: string, args: unknown, workspaceRoot: string | undefined): string | null;
 export declare function parseMcpConfig(json: unknown): McpServerEntry[];

package/dist/types/skills/mcp/mcp-stdio-client.d.ts

@@ -1,8 +1,10 @@
 import type { PortableTool } from "../portable-tool.js";
+import { type McpToolAnnotations } from "./mcp-tool-metadata.js";
 interface McpToolSchema {
     name: string;
     description?: string;
     inputSchema?: Record<string, unknown>;
+    annotations?: McpToolAnnotations;
 }
 interface McpToolCallResult {
     content: Array<{

package/dist/types/skills/mcp/mcp-tool-metadata.d.ts

@@ -0,0 +1,18 @@
+export interface McpToolAnnotations {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    title?: string;
+}
+export interface McpToolMetadataInput {
+    name: string;
+    description?: string;
+    annotations?: McpToolAnnotations;
+}
+export interface McpPortableToolTraits {
+    isReadOnly: boolean;
+    isConcurrencySafe: boolean;
+    isDestructive: boolean;
+}
+export declare function deriveMcpPortableToolTraits(tool: McpToolMetadataInput): McpPortableToolTraits;

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

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

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

@@ -1,70 +1 @@
-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;
+export * from "../../runtime/memory/find-relevant-memories.js";