qlogicagent 2.7.0 → 2.9.0

package/dist/types/runtime/pet/pet-file-loader.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pet File Loader — loads, validates, and sanitizes .pet bundles.
+ *
+ * Design §14.2: .pet is a zip file containing manifest.json + SVG states + thumbnail.
+ * Design §16.2: Security — SVG sanitize (remove scripts, foreign objects, event handlers).
+ *
+ * This module handles:
+ * - Zip extraction
+ * - Manifest JSON Schema validation
+ * - SVG sanitization (whitelist-based)
+ * - File size enforcement
+ */
+export interface PetManifest {
+    version: number;
+    name: string;
+    author: string;
+    created: string;
+    generator?: string;
+    source?: {
+        type: "image" | "text" | "dialogue";
+        prompt?: string;
+    };
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    states: Record<string, {
+        file: string;
+        loop: boolean;
+        duration?: number;
+    }>;
+    eyeTracking?: {
+        enabled: boolean;
+        pupils: string[];
+        maxOffset: number;
+    };
+    colors?: {
+        primary: string;
+        secondary?: string;
+        accent?: string;
+    };
+}
+export interface PetFileBundle {
+    manifest: PetManifest;
+    svgs: Record<string, string>;
+    thumbnail?: string;
+    hash: string;
+}
+/**
+ * Load and validate a .pet file from disk.
+ * Returns a PetFileBundle with sanitized SVGs, or throws on validation failure.
+ */
+export declare function loadPetFile(filePath: string): Promise<PetFileBundle>;
+/**
+ * Validate manifest structure. Throws on invalid.
+ */
+export declare function validatePetManifest(manifest: unknown): asserts manifest is PetManifest;
+/**
+ * Sanitize SVG content — remove dangerous elements and attributes.
+ * Whitelist-based approach (design §16.2).
+ */
+export declare function sanitizeSvg(svgContent: string): string;

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

@@ -0,0 +1,60 @@
+/**
+ * PetGrowthEngine — handles pet leveling, molting (脱壳升级), and ability unlocks.
+ *
+ * Design §13: Growth system
+ * - XP curve: level * 100 (linear P0, polynomial later)
+ * - Molting: every 5 levels triggers a "molt" event with visual upgrade
+ * - Abilities: unlocked at specific levels
+ * - Stats growth: each level-up slightly boosts one stat
+ */
+import type { PetStats, PetSoul } from "./pet-soul-service.js";
+export interface PetAbility {
+    id: string;
+    name: string;
+    description: string;
+    unlockedAtLevel: number;
+}
+export interface GrowthEvent {
+    type: "level_up" | "molt" | "ability_unlock";
+    level: number;
+    ability?: PetAbility;
+    moltStage?: number;
+}
+export interface MoltResult {
+    stage: number;
+    description: string;
+    statBoost: Partial<PetStats>;
+}
+export declare class PetGrowthEngine {
+    /**
+     * Calculate XP needed for next level.
+     * P0: linear 100*level
+     */
+    static xpForLevel(level: number): number;
+    /**
+     * Process XP gain and return all triggered growth events.
+     * Does NOT mutate the soul — caller is responsible for persisting.
+     */
+    static processXpGain(soul: PetSoul, xpGain: number): {
+        newLevel: number;
+        newXp: number;
+        events: GrowthEvent[];
+        statBoosts: Partial<PetStats>;
+    };
+    /**
+     * Get molt result for a given stage.
+     */
+    static getMoltResult(stage: number, currentStats: PetStats): MoltResult;
+    /**
+     * Get all unlocked abilities for a given level.
+     */
+    static getUnlockedAbilities(level: number): PetAbility[];
+    /**
+     * Get next upcoming ability.
+     */
+    static getNextAbility(level: number): PetAbility | null;
+    /**
+     * XP gain rules for different events.
+     */
+    static xpForEvent(event: string): number;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * PetReactionService — probabilistic reaction generation after turns.
+ *
+ * P0: Local template pools (no LLM).
+ * P1+: LLM-generated personalized reactions via small model.
+ */
+import type { PetSoul } from "./pet-soul-service.js";
+export type ReactionPool = "greeting" | "completion" | "error" | "curiosity" | "bored" | "memory" | "tool_success";
+export type ReactionStyle = "normal" | "thinking" | "excited" | "sleepy";
+/**
+ * Determine whether a reaction should fire, and if so, return it.
+ * P0: uses local template pools.
+ */
+export declare function maybeGenerateReaction(eventMethod: string): {
+    text: string;
+    style: ReactionStyle;
+} | null;
+export interface LLMReactionContext {
+    turnSummary: string;
+    soul: PetSoul;
+}
+/**
+ * Generate a personalized reaction via small LLM call.
+ * Returns null on failure or timeout (graceful degradation to template pool).
+ * Max 50 tokens, under 2s.
+ *
+ * @param ctx Context for the reaction
+ * @param llmGenerate External function to call LLM (injected to avoid coupling)
+ */
+export declare function generateLLMReaction(ctx: LLMReactionContext, llmGenerate: (prompt: string, maxTokens: number) => Promise<string | null>): Promise<{
+    text: string;
+    style: ReactionStyle;
+} | null>;

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

@@ -0,0 +1,71 @@
+/**
+ * PetSoulService — manages pet identity (hatching, persistence, stats).
+ *
+ * Hatching: deterministic identity via hash(userId) + LLM-generated soul.
+ * Persistence: stored in project workspace under .qlogicagent/pet/soul.json
+ */
+export interface PetStats {
+    grip: number;
+    patience: number;
+    curiosity: number;
+    appetite: number;
+    humor: number;
+}
+export interface PetSoul {
+    name: string;
+    species: string;
+    personality: string;
+    catchphrase: string;
+    stats: PetStats;
+    rarity: string;
+    breed?: string;
+    breedColors?: {
+        primary: string;
+        secondary: string;
+    };
+    level: number;
+    experience: number;
+    hatchedAt: string;
+}
+/** Breed system (design §6.2): 7 breeds with deterministic hash selection. */
+export interface PetBreed {
+    name: string;
+    colors: {
+        primary: string;
+        secondary: string;
+    };
+    rarity: string;
+}
+export declare class PetSoulService {
+    private workspaceDir;
+    private soul;
+    private storagePath;
+    constructor(workspaceDir: string);
+    /**
+     * Load existing soul from disk. Returns null if not hatched.
+     */
+    load(): PetSoul | null;
+    /**
+     * Hatch a new pet soul. Uses LLM for name/personality/catchphrase.
+     * If generateSoul is provided, uses it; otherwise falls back to defaults.
+     */
+    hatch(userId: string, generateSoul?: (rarity: string, stats: PetStats) => Promise<{
+        name: string;
+        personality: string;
+        catchphrase: string;
+    }>): Promise<PetSoul>;
+    /**
+     * Add experience points. Returns true if leveled up.
+     */
+    addExperience(xp: number): {
+        leveledUp: boolean;
+        level: number;
+        experience: number;
+    };
+    getSoul(): PetSoul | null;
+    /**
+     * Update soul (e.g., after growth/stat changes) and persist.
+     */
+    updateSoul(soul: PetSoul): void;
+    private persist;
+}

package/dist/types/runtime/session/group-session-split.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Group Session Auto-Split — detects idle group sessions and creates successor sessions.
+ *
+ * When a group chat message arrives and the last session activity was > N hours ago,
+ * the old session is sealed and a new session is created with:
+ *   - previousSessionId linking to the predecessor
+ *   - carryoverSummary (from predecessor's taskSummary or last messages)
+ *   - Same groupKey, groupName, groupPlatform, projectId
+ *
+ * This prevents unbounded context growth in long-lived group chats.
+ */
+import { type SessionMetadata } from "./session-persistence.js";
+export interface GroupSplitResult {
+    /** Whether a split occurred */
+    split: boolean;
+    /** The session ID to use for the current turn (new or existing) */
+    activeSessionId: string;
+    /** If split, the sealed predecessor session ID */
+    sealedSessionId?: string;
+}
+/**
+ * Check whether a group session should be auto-split due to idle timeout.
+ * If yes, seal the old session and create a new successor.
+ *
+ * @param currentSession - The existing group session metadata
+ * @param projectRoot - The project workspace directory
+ * @returns Split result with the session ID to use
+ */
+export declare function maybeAutoSplitGroupSession(currentSession: SessionMetadata, projectRoot: string): Promise<GroupSplitResult>;
+/**
+ * Check whether a group session has exceeded MAX_TURNS hard limit.
+ * Called AFTER turn.end — soft-splits without interrupting the current turn.
+ *
+ * @param currentSession - The session that just finished a turn
+ * @param projectRoot - The project workspace directory
+ * @returns Split result (new session ready for next message, or no-op)
+ */
+export declare function maybeHardLimitSplit(currentSession: SessionMetadata, projectRoot: string): Promise<GroupSplitResult>;

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

@@ -1,2 +1,4 @@
-export { SessionState, type SessionUsageSnapshot, type SessionCostSnapshot } from "./session-state.js";
-export { appendMessage, saveSessionState, updateSessionMetadata, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, type SessionMetadata, type PersistedSession, type SessionListEntry, type TaskSummaryDeps, } from "./session-persistence.js";
+export { SessionState, type SessionUsageSnapshot } from "./session-state.js";
+export { SessionLocator } from "./session-locator.js";
+export { appendMessage, saveSessionState, updateSessionMetadata, getSessionMetadata, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, type SessionMetadata, type PersistedSession, type SessionListEntry, type TaskSummaryDeps, } from "./session-persistence.js";
+export { maybeAutoSplitGroupSession, type GroupSplitResult } from "./group-session-split.js";

package/dist/types/runtime/session/session-locator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SessionLocator — resolves session storage paths from projectId.
+ *
+ * Every session operation uses this locator to determine the correct
+ * filesystem path based on the session's owning projectId.
+ * When projectId is missing, falls back to scanning all projects.
+ */
+export declare class SessionLocator {
+    /** Get sessions root directory for a given projectId. */
+    getSessionsRoot(projectId: string): string;
+    /** Get the workspace dir for a project. */
+    getProjectWorkspaceDir(projectId: string): string;
+    /** Get the session directory path for a given projectId + sessionId. */
+    getSessionDir(projectId: string, sessionId: string): string;
+    /**
+     * Resolve the workspaceDir for a session given its projectId.
+     * If projectId is not provided, scans all projects for the session directory.
+     */
+    resolveWorkspaceDir(sessionId: string, projectId?: string): string;
+    /** Get the active project's workspace dir (for new session creation when no projectId specified). */
+    getActiveProjectWorkspaceDir(): string;
+    /** Get the active project's ID. */
+    getActiveProjectId(): string;
+}

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

@@ -1,9 +1,9 @@
 /**
- * SessionMemory 鈥?In-memory session message store with JSONL persistence.
+ * SessionMemoryIn-memory session message store with JSONL persistence.
  *
  * CC alignment: messages live in memory during the session lifetime.
  * JSONL is the sole persistent source of truth (for crash recovery).
- * Gateway never owns message data 鈥?Agent is the single authority.
+ * Gateway never owns message dataAgent is the single authority.
  *
  * Design:
  *   - Map<sessionId, ChatMessage[]> holds active session messages
@@ -15,7 +15,7 @@ import type { ChatMessage } from "../../protocol/wire/index.js";
 export declare class SessionMemory {
     private sessions;
     private projectRoot;
-    constructor(projectRoot?: string);
+    constructor(projectRoot: string);
     setProjectRoot(projectRoot: string): void;
     /**
      * Get messages for a session. Lazy-loads from JSONL on first access.
@@ -35,7 +35,7 @@ export declare class SessionMemory {
     initSession(sessionId: string): void;
     /**
      * Drop a session from memory (e.g., on session.ended).
-     * Does NOT delete JSONL 鈥?data persists for future resume.
+     * Does NOT delete JSONLdata persists for future resume.
      */
     evictSession(sessionId: string): void;
     /**

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

@@ -1,113 +1,113 @@
 /**
- * Session Persistence 鈥?CC sessionRestore.ts + conversationRecovery.ts parity.
+ * Session Persistence — CC sessionRestore.ts + conversationRecovery.ts parity.
  *
  * Enables conversation resume by persisting:
  *   1. Message transcript (JSONL-based, append-only)
- *   2. Cost snapshot (atomic JSON)
- *   3. Session metadata (model, cwd, agent mode)
+ *   2. Session metadata (flat JSON, atomic write)
  *
- * Storage layout:
- *   <project>/.qlogicagent/sessions/<session-id>/   (when projectRoot provided)
- *   ~/.qlogicagent/sessions/<session-id>/            (fallback)
- *     transcript.jsonl   鈥?append-only message log
- *     state.json          鈥?cost snapshot + metadata
+ * Storage layout (ALL data lives under project workspace, NEVER global):
+ *   <project>/.qlogicagent/sessions/<session-id>/
+ *     transcript.jsonl   — append-only message log
+ *     metadata.json      — flat session metadata + usage stats
  *
  * Resume flow (CC processResumedConversation parity):
- *   1. loadSessionForResume(sessionId) 鈫?messages + cost
- *   2. Restore cost state into SessionState
+ *   1. loadSessionForResume(sessionId) → messages + metadata
+ *   2. Restore usage state into SessionState
  *   3. Feed messages as initial context to agent
- *
- * Reference: claude-code src/utils/sessionRestore.ts
- *            claude-code src/utils/conversationRecovery.ts
  */
 import type { ChatMessage } from "../../protocol/wire/index.js";
-import type { SessionCostSnapshot } from "./session-state.js";
+import type { SessionUsageSnapshot } from "./session-state.js";
 export interface SessionMetadata {
     sessionId: string;
-    createdAt: number;
-    lastActiveAt: number;
+    projectId: string;
+    createdAt: string;
+    lastActiveAt: string;
     model?: string;
     cwd?: string;
     turnCount: number;
     messageCount: number;
-    /** Title / description (auto-generated or user-set) */
     title?: string;
-    /** Task summary generated by LLM (CC maybeGenerateTaskSummary parity) */
     taskSummary?: string;
-    /** Timestamp of last task summary generation */
     taskSummaryGeneratedAt?: number;
-    /** ISO timestamp 鈥?session pinned in UI */
     pinnedAt?: string;
-    /** ISO timestamp 鈥?session archived (soft-deleted) */
     archivedAt?: string;
-    /** Project ID this session belongs to */
-    projectId?: string;
-    /** Session type: personal or group */
+    sealedAt?: string;
+    previousSessionId?: string;
+    carryoverSummary?: string;
     type?: "personal" | "group";
-    /** Owner user ID */
     ownerId?: string;
-    /** Group key for group sessions */
     groupKey?: string;
-    /** Group display name */
     groupName?: string;
-    /** Group platform (wechat, dingtalk, etc.) */
     groupPlatform?: string;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
 }
 export interface PersistedSession {
     metadata: SessionMetadata;
     messages: ChatMessage[];
-    costSnapshot?: SessionCostSnapshot;
 }
 export interface SessionListEntry {
     sessionId: string;
     title?: string;
-    lastActiveAt: number;
+    lastActiveAt: string;
     messageCount: number;
     model?: string;
     pinnedAt?: string;
     archivedAt?: string;
-    projectId?: string;
+    sealedAt?: string;
+    projectId: string;
     type?: "personal" | "group";
-    createdAt?: number;
+    createdAt: string;
+    groupKey?: string;
+    previousSessionId?: string;
+    carryoverSummary?: string | null;
 }
+/**
+ * Load session metadata only (lightweight — no transcript loading).
+ * Returns null if session doesn't exist or metadata is unreadable.
+ */
+export declare function getSessionMetadata(sessionId: string, projectRoot: string): SessionMetadata | null;
 /**
  * Append a message to the session transcript.
  * Creates the session directory if it doesn't exist.
  * When turnId is provided, it acts as a per-turn boundary marker enabling
  * reconciliation with Gateway's token_usage records.
+ *
+ * Robustness: catches disk-full and I/O errors without crashing the agent.
+ * Returns false if the write fails.
  */
-export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot?: string, turnId?: string): Promise<void>;
+export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot: string, turnId?: string): Promise<boolean>;
 /**
- * Save session state (cost + metadata) atomically.
+ * Save session metadata + usage stats atomically (flat structure).
  */
-export declare function saveSessionState(sessionId: string, costSnapshot: SessionCostSnapshot, metadata: Partial<SessionMetadata>, projectRoot?: string): Promise<void>;
+export declare function saveSessionState(sessionId: string, usageSnapshot: SessionUsageSnapshot, metadata: Partial<SessionMetadata>, projectRoot: string): Promise<void>;
 /**
  * Update specific metadata fields of a session without touching cost data.
  * Used by session CRUD RPC (rename, pin, archive, move-to-project).
  */
-export declare function updateSessionMetadata(sessionId: string, patch: Partial<SessionMetadata>, projectRoot?: string): Promise<SessionMetadata | null>;
+export declare function updateSessionMetadata(sessionId: string, patch: Partial<Record<keyof SessionMetadata, SessionMetadata[keyof SessionMetadata] | null>>, projectRoot: string): Promise<SessionMetadata | null>;
 /**
- * Load a persisted session for resume 鈥?CC loadConversationForResume parity.
+ * Load a persisted session for resume — CC loadConversationForResume parity.
  *
  * Returns null if the session doesn't exist or is corrupted.
  */
-export declare function loadSessionForResume(sessionId: string, projectRoot?: string): Promise<PersistedSession | null>;
+export declare function loadSessionForResume(sessionId: string, projectRoot: string): Promise<PersistedSession | null>;
 /**
- * List available sessions for resume 鈥?CC ResumeConversation picker.
+ * List available sessions for resume CC ResumeConversation picker.
  * Returns most-recent-first, up to `limit` entries.
  */
-export declare function listSessions(limit?: number, projectRoot?: string): Promise<SessionListEntry[]>;
+export declare function listSessions(limit: number | undefined, projectRoot: string): Promise<SessionListEntry[]>;
 /**
  * Delete a session (cleanup).
  */
-export declare function deleteSession(sessionId: string, projectRoot?: string): Promise<void>;
+export declare function deleteSession(sessionId: string, projectRoot: string): Promise<void>;
 /**
  * Prune old sessions beyond MAX_SESSIONS limit.
  * Deletes oldest sessions first.
  */
-export declare function pruneOldSessions(projectRoot?: string): Promise<number>;
+export declare function pruneOldSessions(projectRoot: string): Promise<number>;
 export interface TaskSummaryDeps {
-    transport: import("../../llm/transport.js").LLMTransport;
+    transport: import("@qlogic/provider-core").LLMTransport;
     apiKey: string;
     model: string;
 }
@@ -117,7 +117,8 @@ export interface TaskSummaryDeps {
  */
 export declare function shouldGenerateTaskSummary(metadata: SessionMetadata): boolean;
 /**
- * Generate and persist a task summary for a long session.
- * Fire-and-forget 鈥?errors are swallowed.
+ * Generate a concise session title from the user's first message.
+ * Lightweight LLM call — one-shot, no tool loop.
  */
-export declare function maybeGenerateTaskSummary(sessionId: string, metadata: SessionMetadata, recentMessages: ChatMessage[], deps: TaskSummaryDeps, projectRoot?: string): Promise<string | null>;
+export declare function generateSessionTitle(userMessage: string, deps: TaskSummaryDeps): Promise<string | null>;
+export declare function maybeGenerateTaskSummary(sessionId: string, metadata: SessionMetadata, recentMessages: ChatMessage[], deps: TaskSummaryDeps, projectRoot: string): Promise<string | null>;

package/dist/types/runtime/session/session-state.d.ts

@@ -1,5 +1,5 @@
 /**
- * Session State 鈥?CC session state parity.
+ * Session State CC session state parity.
  *
  * Unified state container for a single agent session:
  *   - Token usage / cost accumulation across turns
@@ -14,7 +14,7 @@
  * Reference: claude-code src/bootstrap/state.ts, src/cost-tracker.ts
  */
 import type { WireTokenUsage as TokenUsage } from "../../protocol/wire/index.js";
-/** Per-model usage accumulation 鈥?CC modelUsage parity */
+/** Per-model usage accumulation CC modelUsage parity */
 export interface ModelUsage {
     inputTokens: number;
     outputTokens: number;
@@ -36,8 +36,6 @@ export interface SessionUsageSnapshot {
     turnCount: number;
     lastSavedAt: number;
 }
-/** @deprecated Use SessionUsageSnapshot. Kept for persistence compat. */
-export type SessionCostSnapshot = SessionUsageSnapshot;
 export declare class SessionState {
     readonly sessionId: string;
     private _trustAccepted;
@@ -59,7 +57,7 @@ export declare class SessionState {
     /** Get all model usages as a plain object */
     getAllModelUsage(): Record<string, ModelUsage>;
     /**
-     * Add usage from an API response 鈥?CC addToTotalSessionCost() parity.
+     * Add usage from an API response CC addToTotalSessionCost() parity.
      * Tracks token counts only; pricing is handled by Hub/Admin.
      *
      * @param usage - Token counts from the API response

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

@@ -21,7 +21,7 @@ export interface ExtractedMemoryItem {
     tags?: string[];
 }
 export interface LocalMemoryProviderConfig {
-    /** Project root for project-level storage (falls back to user-level). */
+    /** Not used for L2 vector memory (always global). Kept for interface compat. */
     projectRoot?: string;
     /** Embedding configuration. If omitted, uses FTS-only search. */
     embedding?: LocalEmbeddingConfig;

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

@@ -249,6 +249,7 @@ export declare class LocalMemoryStore {
     close(): void;
 }
 /**
- * Resolve the database file path for local memory storage.
+ * Resolve the database file path for L2 vector memory storage.
+ * L2 vector memory is GLOBAL (cross-project knowledge), stored at ~/.qlogicagent/memory/.
  */
-export declare function resolveMemoryDbPath(projectRoot?: string): string;
+export declare function resolveMemoryDbPath(): string;

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

@@ -4,10 +4,10 @@ export declare const INDEX_MAX_CHARS = 12288;
 export declare const INDEX_MAX_LINES = 200;
 /** Max chars for a single topic file. */
 export declare const TOPIC_FILE_MAX_CHARS = 8192;
-/** Root directory: ~/.qlogicagent/memory/ */
-export declare function getMemdirPath(): string;
+/** Root directory: <project>/.qlogicagent/memory/ */
+export declare function getMemdirPath(projectRoot: string): string;
 /** Full path to INDEX.md */
-export declare function getIndexPath(): string;
+export declare function getIndexPath(projectRoot: string): string;
 export interface MemdirFileInfo {
     name: string;
     /** Size in bytes */
@@ -29,7 +29,7 @@ export declare function isMemoryContentSafe(text: string): boolean;
 export declare class Memdir {
     private readonly root;
     private indexCache;
-    constructor(root?: string);
+    constructor(projectRoot: string);
     /** Get the root directory path of this MEMDIR. */
     getRootPath(): string;
     /** Ensure memdir exists with a default INDEX.md if missing. */
@@ -52,6 +52,9 @@ export declare class Memdir {
     /**
      * Auto-compact INDEX.md by removing oldest non-structural entries to make room.
      * Returns the compacted content with the new entry appended, or null if impossible.
+     *
+     * Entry-aware: removes complete logical entries (a non-indented line plus its
+     * continuation lines that start with whitespace/'-') to avoid half-entries.
      */
     private autoCompactIndex;
     /** Replace text in INDEX.md (str_replace semantics). */

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

@@ -7,7 +7,7 @@
 import type { LocalEmbeddingConfig } from "./local-embedding.js";
 import type { LocalMemoryProvider } from "./local-memory-provider.js";
 export interface MemoryProviderFactoryConfig {
-    /** Project root for local storage path. */
+    /** Not used for L2 vector DB (always global). Kept for config compat. */
     projectRoot?: string;
     /** User ID prefix. */
     userIdPrefix?: string;
@@ -44,11 +44,5 @@ export declare function createMemoryProvider(config: MemoryProviderFactoryConfig
  *   Layer 3: FTS5 pure text (NullEmbeddingProvider)
  *
  * @param projectRoot — Project root for local storage path
- * @param embeddingOverride — TurnConfig.embeddingModel override (takes priority over env vars)
  */
-export declare function resolveMemoryConfigFromEnv(projectRoot?: string, embeddingOverride?: {
-    provider?: string;
-    model?: string;
-    apiKey?: string;
-    baseUrl?: string;
-}): MemoryProviderFactoryConfig;
+export declare function resolveMemoryConfigFromEnv(projectRoot?: string): MemoryProviderFactoryConfig;

package/dist/types/skills/permissions/denial-audit-log.d.ts

@@ -38,7 +38,7 @@ export interface DenialAuditEntry {
 export declare class DenialAuditLogger {
     private filePath;
     private writeQueue;
-    constructor(projectRoot?: string);
+    constructor(projectRoot: string);
     /**
      * Append a denial event to the audit log.
      * Non-blocking; errors are swallowed to avoid disrupting agent flow.

package/dist/types/skills/permissions/permission-classifier.d.ts

@@ -6,7 +6,7 @@ export interface ClassifierResult {
     durationMs: number;
 }
 /**
- * LLM call interface 鈥?injected by the host so the classifier
+ * LLM call interfaceinjected by the host so the classifier
  * doesn't depend on a specific LLM client.
  */
 export interface ClassifierLLMCall {

package/dist/types/skills/tools/search-tool.d.ts

@@ -87,7 +87,7 @@ export interface SearchToolDeps {
      * The implementation may use ripgrep, native grep, or a custom engine.
      * Returns match records.
      * The host SHOULD auto-exclude VCS directories (.git, .svn, .hg, .bzr)
-     * and enforce --max-columns 500 to avoid minified file noise.
+     * and enforcemax-columns 500 to avoid minified file noise.
      */
     grep(pattern: string, options: {
         cwd: string;