qlogicagent 2.10.22 → 2.10.23

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";

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

@@ -1,58 +1 @@
-/**
- * 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 { LocalMemoryProvider } from "./local-memory-provider.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: LocalMemoryProvider;
-    /** 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>;
+export * from "../../runtime/memory/implicit-extraction.js";

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

@@ -11,19 +11,13 @@
 import type { MemoryProvider, MemorySearchResult, MemorySearchOptions, MemoryIngestMessage, MemoryIngestOptions } from "../../protocol/wire/index.js";
 import type { MemoryClaimRecord, MemoryConflictRecord, MemoryUpdateInput, SqliteDatabase } from "./local-store.js";
 import { type LocalEmbeddingConfig } from "./local-embedding.js";
-import { type MemoryConsolidationResult } from "./memory-consolidation.js";
-/** A pre-extracted memory item ready to be stored (no LLM needed). */
-export interface ExtractedMemoryItem {
-    text: string;
-    category?: string;
-    importance?: number;
-    speaker?: string;
-    event_date?: string;
-    tags?: string[];
-}
+import { type ExtractedMemoryItem, type MemoryConsolidationResult } from "./memory-consolidation.js";
+export type { ExtractedMemoryItem } from "./memory-consolidation.js";
 export interface LocalMemoryProviderConfig {
     /** Not used for L2 vector memory (always global). Kept for interface compat. */
     projectRoot?: string;
+    /** Active owner profile. Determines the physical SQLite database location. */
+    ownerUserId?: string;
     /** Embedding configuration. If omitted, uses FTS-only search. */
     embedding?: LocalEmbeddingConfig;
     /** User ID prefix for multi-tenant isolation. */

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

@@ -5,8 +5,7 @@
  * Uses better-sqlite3 for synchronous, fast, single-file persistence.
  *
  * Storage location:
- *   <project>/.qlogicagent/memory/memories.db    (project-level)
- *   ~/.qlogicagent/memory/memories.db             (user-level fallback)
+ *   ~/.qlogicagent/profiles/<owner_user_id>/memory/memories.db
  *
  * Schema:
  *   - memories: core fact storage with optional embedding blob
@@ -420,6 +419,7 @@ export declare class LocalMemoryStore {
 }
 /**
  * Resolve the database file path for L2 vector memory storage.
- * L2 vector memory is GLOBAL (cross-project knowledge), stored at ~/.qlogicagent/memory/.
+ * L2 vector memory is cross-project for one owner, but physically isolated by
+ * profile at ~/.qlogicagent/profiles/<owner_user_id>/memory/.
  */
-export declare function resolveMemoryDbPath(): string;
+export declare function resolveMemoryDbPath(ownerUserId?: string): string;

package/dist/types/skills/memory/memory-consolidation.d.ts

@@ -1,5 +1,13 @@
 import { LocalMemoryStore } from "./local-store.js";
-import type { ExtractedMemoryItem } from "./local-memory-provider.js";
+/** A pre-extracted memory item ready to be stored (no LLM needed). */
+export interface ExtractedMemoryItem {
+    text: string;
+    category?: string;
+    importance?: number;
+    speaker?: string;
+    event_date?: string;
+    tags?: string[];
+}
 export interface MemoryConsolidationOptions {
     source?: string;
     sessionId?: string;

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

@@ -9,6 +9,8 @@ import type { LocalMemoryProvider } from "./local-memory-provider.js";
 export interface MemoryProviderFactoryConfig {
     /** Not used for L2 vector DB (always global). Kept for config compat. */
     projectRoot?: string;
+    /** Active owner profile. All local memory files are physically scoped here. */
+    ownerUserId: string;
     /** User ID prefix. */
     userIdPrefix?: string;
     /** Embedding config for local provider. */

package/dist/types/skills/memory/memory-tool.d.ts

@@ -1,6 +1,4 @@
-import type { MemoryProvider, MemorySearchResult } from "../../protocol/wire/index.js";
-import type { LocalMemoryProvider } from "./local-memory-provider.js";
-import type { Memdir } from "./memdir.js";
+import type { MemoryProvider, MemorySearchResult, MemoryToolLocalProvider, ProjectMemoryStore } from "../../runtime/ports/index.js";
 export declare const MEMORY_TOOL_NAME: "memory";
 export declare const MEMORY_TOOL_LABEL = "Memory";
 export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "create_file", "write_file", "read_file", "delete_file", "list_files", "search", "remember", "temporal", "feedback"];
@@ -78,10 +76,10 @@ export interface MemoryToolResult {
     results?: MemorySearchResult[];
 }
 export interface MemoryToolExecutorDeps {
-    memdir: Memdir;
+    memdir: ProjectMemoryStore;
     provider?: MemoryProvider;
-    /** LocalMemoryProvider for temporal/feedback (typed narrow for advanced ops). */
-    localProvider?: LocalMemoryProvider;
+    /** Runtime memory provider for temporal/feedback (typed narrow for advanced ops). */
+    localProvider?: MemoryToolLocalProvider;
     userId: string;
 }
 export declare function executeMemoryTool(params: MemoryToolParams, deps: MemoryToolExecutorDeps): Promise<MemoryToolResult>;

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

@@ -1,54 +1 @@
-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;
+export * from "../../runtime/memory/recall-category-filter.js";

package/dist/types/skills/permissions/community-sandbox-policy.d.ts

@@ -0,0 +1,3 @@
+import type { PermissionRuleEntry } from "./types.js";
+export type CommunitySandboxRuleId = "community-l1-shell" | "community-l1-file-read" | "community-l1-file-write" | "community-l1-network" | "community-l1-mcp" | "community-l1-host-control" | "community-l2-host-side-effect" | "community-l2-data-egress" | "community-l2-provider-prompt-egress" | "community-l2-provider-media-egress";
+export declare function createCommunityL1SandboxRules(): PermissionRuleEntry[];

package/dist/types/skills/permissions/community-sandbox-red-team-cli.d.ts

@@ -0,0 +1,7 @@
+export interface CommunitySandboxRedTeamCliDeps {
+    log?: {
+        info(message: string): void;
+        error(message: string): void;
+    };
+}
+export declare function runCommunitySandboxRedTeamCli(argv?: string[], deps?: CommunitySandboxRedTeamCliDeps): Promise<number>;

package/dist/types/skills/permissions/community-sandbox-red-team.d.ts

@@ -0,0 +1,30 @@
+export type CommunitySandboxRedTeamFinding = "community-sandbox:shell-exec" | "community-sandbox:file-read" | "community-sandbox:file-write" | "community-sandbox:network-egress" | "community-sandbox:mcp-call" | "community-sandbox:host-side-effect" | "community-sandbox:data-egress" | "community-sandbox:provider-prompt-egress" | "community-sandbox:provider-media-egress";
+export interface CommunitySandboxRedTeamCase {
+    id: string;
+    expectedFinding: CommunitySandboxRedTeamFinding;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+}
+export interface CommunitySandboxRedTeamReport {
+    suite: "sandbox";
+    generatedAt: string;
+    cases: number;
+    passed: boolean;
+    failures: number;
+    telemetryEvents: number;
+    approvalRequests: number;
+    breakdown: Record<CommunitySandboxRedTeamFinding, {
+        cases: number;
+        failures: number;
+    }>;
+    failureDetails: Array<{
+        id: string;
+        expectedFinding: CommunitySandboxRedTeamFinding;
+        action: "continue" | "abort" | "skip" | "prevent";
+        reason?: string;
+        telemetryRecorded: boolean;
+        approvalRecorded: boolean;
+    }>;
+}
+export declare function buildCommunitySandboxRedTeamCases(): CommunitySandboxRedTeamCase[];
+export declare function runCommunitySandboxRedTeam(cases?: CommunitySandboxRedTeamCase[]): Promise<CommunitySandboxRedTeamReport>;