@jawcode-dev/coding-agent 1.1.0

package/dist/types/lsp/utils.d.ts

@@ -0,0 +1,108 @@
+export { truncate } from "@jawcode-dev/utils";
+import type { CodeAction, Command, Diagnostic, DiagnosticSeverity, DocumentSymbol, Location, SymbolInformation, SymbolKind, TextEdit, WorkspaceEdit } from "./types";
+export { detectLanguageId } from "../utils/lang-from-path";
+/**
+ * Convert a file path to a file:// URI.
+ * Handles Windows drive letters correctly.
+ */
+export declare function fileToUri(filePath: string): string;
+/**
+ * Convert a file:// URI to a file path.
+ * Handles Windows drive letters correctly.
+ */
+export declare function uriToFile(uri: string): string;
+/**
+ * Convert diagnostic severity number to string name.
+ */
+export declare function severityToString(severity?: DiagnosticSeverity): string;
+/**
+ * Sort diagnostics by severity, then by location and message.
+ */
+export declare function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[];
+/**
+ * Get icon for diagnostic severity.
+ */
+export declare function severityToIcon(severity?: DiagnosticSeverity): string;
+/**
+ * Format a diagnostic as a human-readable string.
+ */
+export declare function formatDiagnostic(diagnostic: Diagnostic, filePath: string): string;
+/**
+ * Reformat pre-formatted diagnostic messages into grep-style directory/file groups.
+ * Input:  ["path:line:col [sev] msg", ...]
+ * Output: "# dir/\n## file.ts\n  line:col [sev] msg"
+ *
+ * Messages that don't match the expected format are appended ungrouped at the end.
+ */
+export declare function formatGroupedDiagnosticMessages(messages: string[]): string;
+/**
+ * Format diagnostics grouped by severity.
+ */
+export declare function formatDiagnosticsSummary(diagnostics: Diagnostic[]): string;
+/**
+ * Format a location as file:line:col relative to cwd.
+ */
+export declare function formatLocation(location: Location, cwd: string): string;
+/**
+ * Format a position as line:col.
+ */
+export declare function formatPosition(line: number, col: number): string;
+/**
+ * Format a workspace edit as a summary of changes.
+ */
+export declare function formatWorkspaceEdit(edit: WorkspaceEdit, cwd: string): string[];
+/**
+ * Format a text edit as a preview.
+ */
+export declare function formatTextEdit(edit: TextEdit, maxLength?: number): string;
+/**
+ * Get icon for symbol kind.
+ */
+export declare function symbolKindToIcon(kind: SymbolKind): string;
+/**
+ * Get name for symbol kind.
+ */
+export declare function symbolKindToName(kind: SymbolKind): string;
+/**
+ * Format a document symbol with optional hierarchy.
+ */
+export declare function formatDocumentSymbol(symbol: DocumentSymbol, indent?: number): string[];
+/**
+ * Format a symbol information (flat format).
+ */
+export declare function formatSymbolInformation(symbol: SymbolInformation, cwd: string): string;
+export declare function filterWorkspaceSymbols(symbols: SymbolInformation[], query: string): SymbolInformation[];
+export declare function dedupeWorkspaceSymbols(symbols: SymbolInformation[]): SymbolInformation[];
+export declare function formatCodeAction(action: CodeAction | Command, index: number): string;
+export interface CodeActionApplyDependencies {
+    resolveCodeAction?: (action: CodeAction) => Promise<CodeAction>;
+    applyWorkspaceEdit: (edit: WorkspaceEdit) => Promise<string[]>;
+    executeCommand: (command: Command) => Promise<void>;
+}
+export interface AppliedCodeActionResult {
+    title: string;
+    edits: string[];
+    executedCommands: string[];
+}
+export declare function applyCodeAction(action: CodeAction | Command, dependencies: CodeActionApplyDependencies): Promise<AppliedCodeActionResult | null>;
+export declare function hasGlobPattern(value: string): boolean;
+export declare function collectGlobMatches(pattern: string, cwd: string, maxMatches: number): Promise<{
+    matches: string[];
+    truncated: boolean;
+}>;
+export declare function resolveDiagnosticTargets(file: string, cwd: string, maxMatches: number): Promise<{
+    matches: string[];
+    truncated: boolean;
+}>;
+/**
+ * Extract plain text from hover contents.
+ */
+export declare function extractHoverText(contents: string | {
+    kind: string;
+    value: string;
+} | {
+    language: string;
+    value: string;
+} | unknown[]): string;
+export declare function resolveSymbolColumn(filePath: string, line: number, symbolSpec?: string): Promise<number>;
+export declare function readLocationContext(filePath: string, line: number, contextLines?: number): Promise<string[]>;

package/dist/types/main.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Main entry point for the coding agent CLI.
+ *
+ * This file handles CLI argument parsing and translates them into
+ * createAgentSession() options. The SDK does the heavy lifting.
+ */
+import { postmortem } from "@jawcode-dev/utils";
+import type { Args } from "./cli/args";
+import { ModelRegistry } from "./config/model-registry";
+import { type ScopedModel } from "./config/model-resolver";
+import { Settings } from "./config/settings";
+import { InteractiveMode, runAcpMode, runBridgeMode, runPrintMode } from "./modes";
+import type { SubmittedUserInput } from "./modes/types";
+import { discoverAndLoadMCPTools } from "./runtime-mcp";
+import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
+import type { AgentSession } from "./session/agent-session";
+import type { AuthStorage } from "./session/auth-storage";
+import { SessionManager } from "./session/session-manager";
+export interface InteractiveModeNotify {
+    kind: "warn" | "error" | "info";
+    message: string;
+}
+export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested" | "prepareRealUserAgentPromptSubmission">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
+export interface AcpSessionFactoryOptions {
+    baseOptions: CreateAgentSessionOptions;
+    settings: Settings;
+    sessionDir?: string;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+    parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
+    rawArgs: string[];
+    createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
+}
+export declare function applyStartupModelProfiles(args: {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+    startupModel?: CreateAgentSessionOptions["model"];
+    startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+}): Promise<void>;
+export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof applyStartupModelProfiles>[0]): Promise<void>;
+/**
+ * Build the per-`session/new` factory used by ACP mode.
+ *
+ * MCP servers in ACP sessions are owned exclusively by the ACP client, which
+ * supplies them through `session/new.mcpServers` and re-applies them via
+ * {@link AcpAgent#configureMcpServers}. We therefore force `enableMCP: false`
+ * on every session created here so {@link createAgentSession} skips the on-disk
+ * `.mcp.json` discovery path — otherwise host MCP tools land in the session's
+ * tool registry and shadow the client-supplied servers (issue #1234).
+ */
+export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+declare function buildSessionOptions(parsed: Args, scopedModels: ScopedModel[], sessionManager: SessionManager | undefined, modelRegistry: ModelRegistry, activeSettings: Settings): Promise<{
+    options: CreateAgentSessionOptions;
+}>;
+interface RunRootCommandDependencies {
+    createAgentSession?: typeof createAgentSession;
+    discoverAuthStorage?: typeof discoverAuthStorage;
+    discoverAndLoadMCPTools?: typeof discoverAndLoadMCPTools;
+    buildSessionOptions?: typeof buildSessionOptions;
+    applyStartupModelProfiles?: typeof applyStartupModelProfiles;
+    runPrintMode?: typeof runPrintMode;
+    runBridgeMode?: typeof runBridgeMode;
+    postmortemQuit?: typeof postmortem.quit;
+    runAcpMode?: typeof runAcpMode;
+    settings?: Settings;
+}
+export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
+export declare function main(args: string[]): Promise<void>;
+export {};

package/dist/types/mem0/backend.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryBackend } from "../memory-backend/types";
+export declare const mem0Backend: MemoryBackend;

package/dist/types/mem0/client.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Minimal fetch client for Mem0 Platform V3 (https://api.mem0.ai).
+ */
+import type { Mem0Config } from "./config";
+export interface Mem0SearchHit {
+    id: string;
+    memory: string;
+    score?: number;
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+export interface Mem0SearchResponse {
+    results: Mem0SearchHit[];
+}
+export interface Mem0AddResponse {
+    message?: string;
+    status?: string;
+    event_id?: string;
+}
+export declare class Mem0Error extends Error {
+    readonly status: number;
+    readonly body?: string | undefined;
+    constructor(message: string, status: number, body?: string | undefined);
+}
+export declare class Mem0Api {
+    #private;
+    constructor(config: Mem0Config & {
+        mem0ApiKey: string;
+    });
+    search(query: string, filters: Record<string, unknown>, topK: number): Promise<Mem0SearchResponse>;
+    getMemory(memoryId: string): Promise<Record<string, unknown>>;
+    add(messages: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+    }>, params: {
+        userId: string;
+        agentId?: string;
+        runId?: string;
+        metadata?: Record<string, unknown>;
+        infer?: boolean;
+    }): Promise<Mem0AddResponse>;
+    private getJson;
+    private postJson;
+    private headers;
+    private parseJson;
+}
+export declare function createMem0Client(config: Mem0Config & {
+    mem0ApiKey: string;
+}): Mem0Api;

package/dist/types/mem0/config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Mem0 Platform API configuration (https://api.mem0.ai).
+ *
+ * Precedence: MEM0_* env vars override settings schema defaults.
+ */
+import type { Settings } from "../config/settings";
+export type Mem0Scoping = "global" | "per-project" | "per-project-tagged";
+export interface Mem0Config {
+    mem0ApiKey: string | null;
+    mem0ApiUrl: string;
+    userId: string | null;
+    userIdPrefix: string;
+    agentId: string;
+    scoping: Mem0Scoping;
+    autoRecall: boolean;
+    autoRetain: boolean;
+    retainEveryNTurns: number;
+    searchTopK: number;
+    recallPreamble: string;
+}
+export declare function loadMem0Config(settings: Settings, env?: NodeJS.ProcessEnv): Mem0Config;
+export declare function isMem0Configured(config: Mem0Config): config is Mem0Config & {
+    mem0ApiKey: string;
+};

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

@@ -0,0 +1,5 @@
+export * from "./backend";
+export * from "./client";
+export * from "./config";
+export * from "./scope";
+export * from "./state";

package/dist/types/mem0/scope.d.ts

@@ -0,0 +1,12 @@
+import type { Mem0Config } from "./config";
+export interface Mem0EntityScope {
+    userId: string;
+    agentId: string;
+    runId?: string;
+    searchFilters: Record<string, unknown>;
+    retainMetadata: Record<string, unknown>;
+}
+/**
+ * Resolve Mem0 V3 `filters` entity scope for a working directory and optional session run id.
+ */
+export declare function computeMem0Scope(config: Mem0Config, directory: string, runId?: string): Mem0EntityScope;

package/dist/types/mem0/state.d.ts

@@ -0,0 +1,36 @@
+import type { AgentSession } from "../session/agent-session";
+import type { Mem0Api } from "./client";
+import type { Mem0Config } from "./config";
+import type { Mem0EntityScope } from "./scope";
+export interface Mem0SessionStateOptions {
+    sessionId: string;
+    client: Mem0Api;
+    scope: Mem0EntityScope;
+    config: Mem0Config;
+    session: AgentSession;
+}
+export declare class Mem0SessionState {
+    #private;
+    readonly sessionId: string;
+    readonly client: Mem0Api;
+    readonly scope: Mem0EntityScope;
+    readonly config: Mem0Config;
+    readonly session: AgentSession;
+    lastRecallSnippet?: string;
+    hasRecalledForFirstTurn: boolean;
+    lastRetainedTurn: number;
+    constructor(options: Mem0SessionStateOptions);
+    setSessionId(sessionId: string): void;
+    resetConversationTracking(): void;
+    formatSearchHits(hits: Array<{
+        id: string;
+        memory: string;
+        score?: number;
+    }>): string;
+    recallForQuery(query: string): Promise<string | undefined>;
+    beforeAgentStartPrompt(promptText: string): Promise<string | undefined>;
+    maybeRetainOnAgentEnd(): Promise<void>;
+    forceRetainCurrentSession(): Promise<void>;
+    attachSessionListeners(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,28 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { AgentSession } from "../session/agent-session";
+/**
+ * Start the background memory startup pipeline.
+ *
+ * Skips for ephemeral sessions, subagent sessions, disabled settings, or DB failures.
+ */
+export declare function startMemoryStartupTask(options: {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    agentDir: string;
+    taskDepth: number;
+}): void;
+/**
+ * Build memory usage instructions for prompt injection.
+ */
+export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings, session?: AgentSession): Promise<string | undefined>;
+/**
+ * Clear all persisted memory state and generated artifacts.
+ */
+export declare function clearMemoryData(agentDir: string, cwd: string): Promise<void>;
+/**
+ * Force-enqueue global consolidation maintenance work.
+ */
+export declare function enqueueMemoryConsolidation(agentDir: string, cwd: string, sourceUpdatedAt?: number): void;
+export declare function getMemoryRoot(agentDir: string, cwd: string): string;

package/dist/types/memories/local-query.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Query/save surface over the local memories pipeline (99.01 M2).
+ *
+ * The engine (`memories/index.ts` + `storage.ts`) is an automatic
+ * summarisation pipeline with no search verbs; this module adds the
+ * cli-jaw-shaped read side without touching the schema. Ranking is the
+ * 1st-iteration contract from 99.01.01 §2: SQL LIKE + kind weight +
+ * recency — FTS5/RRF are follow-ups.
+ *
+ * Manual saves write straight into `stage1_outputs` (the
+ * `markStage1SucceededWithOutput` path requires a running job's
+ * ownership token, which manual rows never hold) and join phase2
+ * consolidation through the normal watermark queue.
+ */
+import type { Database } from "bun:sqlite";
+import { type MemorySearchMode } from "./memory-config";
+export type LocalMemoryKind = "profile" | "shared" | "episode";
+export interface LocalMemoryHit {
+    /** Stable reference usable with `readLocalMemoryArtifact` (e.g. "memory", "summary", "stage1:<id>"). */
+    ref: string;
+    kind: LocalMemoryKind;
+    line?: number;
+    snippet: string;
+    /** Lower is better (cli-jaw score semantics). */
+    score: number;
+    generatedAt?: number;
+}
+/** Canonical ref aliases accepted by read/context (99.01 M7). */
+export declare function normalizeLocalMemoryRef(ref: string): string;
+export interface LocalMemorySearchOptions {
+    /** When non-empty, restrict episode/manual hits to threads whose rollout path matches a spec; profile/shared artifacts always pass. */
+    scopePaths?: string[];
+    /** Override settings `memories.searchMode` for this query. */
+    searchMode?: MemorySearchMode;
+}
+export declare function filterScopePaths(hits: LocalMemoryHit[], scopePaths: string[] | undefined, rolloutByThread: Map<string, string>): LocalMemoryHit[];
+/** Expand query terms with the seeded synonym groups (both directions). */
+export declare function expandQueryTerms(query: string): string[];
+/**
+ * FTS5 search over stage1 rows (LIKE fallback) + generated artifacts for one project.
+ * Returns up to `limit` hits sorted by score (lower = better).
+ */
+export declare function searchMemoriesCore(agentDir: string, cwd: string, query: string, limit?: number, options?: LocalMemorySearchOptions): LocalMemoryHit[];
+export declare function searchLocalMemories(agentDir: string, cwd: string, query: string, limit?: number, options?: LocalMemorySearchOptions): LocalMemoryHit[];
+export interface ReadArtifactResult {
+    ref: string;
+    content: string;
+}
+/**
+ * Read a memory artifact or record by ref vocabulary:
+ * `summary` | `memory` | `raw` | `stage1:<thread_id>` | `rollout:<slug>`
+ * (+ artifact basename compatibility). Optional `lines` = "a-b" range.
+ */
+export declare function readLocalMemoryArtifact(agentDir: string, cwd: string, ref: string, lines?: string): ReadArtifactResult | null;
+export interface SaveManualResult {
+    threadId: string;
+    enqueued: boolean;
+}
+/**
+ * Save a manual memory as a stage1 row (`manual:<file>` thread id) and bump
+ * the phase2 watermark so consolidation naturally folds it in. Direct
+ * INSERT...ON CONFLICT — the job-owned write path is not applicable here.
+ */
+export declare function saveLocalMemoryManual(agentDir: string, cwd: string, file: string, content: string, kind?: LocalMemoryKind): SaveManualResult;
+export interface MemoryContextResult {
+    ref: string;
+    threadId: string;
+    sourceKind: string;
+    rolloutPath: string;
+    updatedAt: number;
+    record: string;
+    /** Neighbouring rollout evidence when the source jsonl still exists. */
+    rolloutExcerpt?: string;
+}
+/**
+ * Resolve a stage1/manual ref back to its thread row and (when the rollout
+ * jsonl still exists) a short excerpt of surrounding evidence.
+ */
+export declare function contextLocalMemory(agentDir: string, cwd: string, ref: string): MemoryContextResult | null;
+/**
+ * Build the per-turn Task Snapshot block body (99.01 M6): top-N hits for the
+ * current prompt, diversified (episodes capped at 2, one hit per ref).
+ */
+export interface LocalMemoryBrowseRow {
+    ref: string;
+    kind: LocalMemoryKind;
+    updatedAt: number;
+    snippet: string;
+}
+/** Recent memory index for `memory browse` (99.01 M7): artifacts + stage1 rows, newest first. */
+export declare function browseLocalMemories(agentDir: string, cwd: string, limit?: number): LocalMemoryBrowseRow[];
+export declare function buildLocalTaskSnapshot(agentDir: string, cwd: string, promptText: string, topN?: number, options?: Pick<LocalMemorySearchOptions, "searchMode">): string | null;
+export interface LocalMemoryStatus {
+    backend: "local";
+    stage1Count: number;
+    ftsStage1IndexedCount: number;
+    ftsArtifactIndexedCount: number;
+    artifactProfile: boolean;
+    artifactSummary: boolean;
+    pendingGlobalJobs: number;
+}
+/** Compact ref listing for `memory list` (99.01 M8). */
+export declare function listLocalMemoryRefs(agentDir: string, cwd: string, limit?: number): string[];
+/** Local backend health counters for `memory status` (99.01 M8). */
+export declare function getLocalMemoryStatus(agentDir: string, cwd: string): LocalMemoryStatus;
+/** Rebuild FTS5 index from stage1_outputs (`memory reindex`, 99.01 M8). */
+/** Index on-disk MEMORY.md / memory_summary.md into artifact FTS (used after consolidation + reindex). */
+export declare function syncArtifactFilesToFts(db: Database, memoryRoot: string): void;
+export declare function reindexLocalMemoryFts(agentDir: string, memoryRoot?: string): {
+    indexedStage1: number;
+    indexedArtifacts: number;
+};

package/dist/types/memories/memory-config.d.ts

@@ -0,0 +1,46 @@
+import type { Settings } from "../config/settings";
+/** Local memory query backend for stage1 + artifacts (99.01 M2). */
+export type MemorySearchMode = "hybrid" | "fts" | "like";
+export interface MemoryRuntimeConfig {
+    enabled: boolean;
+    maxRolloutsPerStartup: number;
+    maxRolloutAgeDays: number;
+    minRolloutIdleHours: number;
+    threadScanLimit: number;
+    maxRawMemoriesForGlobal: number;
+    stage1Concurrency: number;
+    stage1LeaseSeconds: number;
+    stage1RetryDelaySeconds: number;
+    phase2LeaseSeconds: number;
+    phase2RetryDelaySeconds: number;
+    phase2HeartbeatSeconds: number;
+    rolloutPayloadPercent: number;
+    phase1InputTokenLimit: number;
+    fallbackTokenLimit: number;
+    summaryInjectionTokenLimit: number;
+    /** Optional override for stage1/phase2 model (provider/model or pi/ role alias). */
+    modelRolePattern?: string;
+    /** FTS5 vs LIKE for `searchLocalMemories` (default hybrid: FTS with LIKE fallback). */
+    searchMode: MemorySearchMode;
+    /** CLI/search surface default (99.01 M7). */
+    searchLimit: number;
+    /** `memory browse` row cap (99.01 M7). */
+    browseLimit: number;
+    /** Per-turn task snapshot caps (99.01 M9). */
+    taskSnapshotTopN: number;
+    taskSnapshotEpisodeCap: number;
+    taskSnapshotMaxChars: number;
+    searchMaxChars: number;
+    snapshotSnippetChars: number;
+    searchSnippetChars: number;
+    hitCountDedupThreshold: number;
+    compactedTaskSnapshotTopN: number;
+    compactedTaskSnapshotEpisodeCap: number;
+    compactedTaskSnapshotMaxChars: number;
+    compactedSnapshotSnippetChars: number;
+    compactedSearchSnippetChars: number;
+    compactionContextMaxChars: number;
+}
+export declare const MEMORY_RUNTIME_DEFAULTS: MemoryRuntimeConfig;
+/** Settings → pipeline + CLI query limits (single handoff surface for runtime + local-query). */
+export declare function loadMemoryConfig(settings: Settings): MemoryRuntimeConfig;

package/dist/types/memories/memory-fts.d.ts

@@ -0,0 +1,51 @@
+/**
+ * FTS5 full-text indexes for local memory (99.01 M2).
+ * Standalone FTS tables — stage1 uses `thread_id`; artifacts use `ref` (TEXT PKs elsewhere).
+ */
+import type { Database } from "bun:sqlite";
+/** Create FTS virtual table + insert/delete triggers; stage1 updates sync via {@link syncStage1FtsRow}. */
+export declare function ensureMemoryStage1Fts(db: Database): void;
+/** FTS index for consolidated `MEMORY.md` / `memory_summary.md` (ref-keyed, manual sync). */
+export declare function ensureMemoryArtifactFts(db: Database): void;
+export declare function ensureMemoryFtsIndexes(db: Database): void;
+/** Upsert one stage1 row into the FTS index (used on UPDATE paths that skip the broken FTS5 update trigger). */
+export declare function syncStage1FtsRow(db: Database, params: {
+    threadId: string;
+    rawMemory: string;
+    rolloutSummary: string;
+}): void;
+export declare function removeMemoryArtifactFtsRow(db: Database, ref: string): void;
+/** Upsert one artifact ref (`memory` | `summary`) into the artifact FTS index. */
+export declare function syncMemoryArtifactFtsRow(db: Database, params: {
+    ref: string;
+    body: string;
+}): void;
+export declare function rebuildMemoryStage1Fts(db: Database): void;
+export declare function rebuildMemoryArtifactFts(db: Database): void;
+export declare function rebuildAllMemoryFts(db: Database): void;
+/**
+ * Build an FTS5 MATCH expression from expanded query terms (prefix OR).
+ * Returns null when there are no usable terms.
+ */
+export declare function buildStage1FtsMatchQuery(terms: string[]): string | null;
+export declare const buildFtsMatchQuery: typeof buildStage1FtsMatchQuery;
+export interface Stage1FtsHitRow {
+    thread_id: string;
+    raw_memory: string;
+    rollout_summary: string;
+    rollout_slug: string | null;
+    generated_at: number;
+    rank: number;
+}
+export interface ArtifactFtsHitRow {
+    ref: string;
+    body: string;
+    rank: number;
+}
+/**
+ * Full-text search over stage1 outputs for one project cwd.
+ * Lower `rank` from bm25() is a stronger match.
+ */
+export declare function searchStage1FtsRows(db: Database, cwd: string, matchQuery: string, limit: number): Stage1FtsHitRow[];
+/** Full-text search over indexed artifact bodies (`memory`, `summary` refs). */
+export declare function searchArtifactFtsRows(db: Database, matchQuery: string, limit: number): ArtifactFtsHitRow[];

package/dist/types/memories/memory-model-resolution.d.ts

@@ -0,0 +1,20 @@
+import type { Model } from "@jawcode-dev/ai";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { AgentSession } from "../session/agent-session";
+export interface MemoryModelResolutionRecord {
+    pattern: string;
+    provider: string;
+    modelId: string;
+    resolvedAt: number;
+    source: "memories.modelRolePattern" | "modelRoles.memory" | "modelRoles.fallback" | "session.model";
+}
+/** Pick the configured pattern for background memory jobs (stage1 / phase2). */
+export declare function resolveMemoryModelPattern(settings: Settings, fallbackRole: string, modelRolePattern?: string): {
+    pattern?: string;
+    source: MemoryModelResolutionRecord["source"];
+};
+export declare function resolveMemoryModelFromPattern(pattern: string | undefined, session: AgentSession, modelRegistry: ModelRegistry): Model | undefined;
+export declare function persistMemoryModelResolution(agentDir: string, cwd: string, record: MemoryModelResolutionRecord): Promise<void>;
+export declare function readMemoryModelResolution(agentDir: string, cwd: string): Promise<MemoryModelResolutionRecord | null>;
+export declare function formatResolvedMemoryModelLine(model: Model): string;

package/dist/types/memories/memory-quality.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Local memory quality gates (99.01 M9): character budgets, post-compaction recall
+ * caps, and hit-count dedup for search/snapshot surfaces.
+ */
+import type { Database } from "bun:sqlite";
+import type { CompactionEntry, SessionEntry } from "../session/session-manager";
+import type { LocalMemoryHit } from "./local-query";
+import type { MemoryRuntimeConfig } from "./memory-config";
+export interface MemorySnapshotLimits {
+    topN: number;
+    episodeCap: number;
+    snippetChars: number;
+    maxTotalChars: number;
+}
+export declare function sessionIsCompactionAware(entries: SessionEntry[]): boolean;
+export declare function resolveSnapshotLimits(config: MemoryRuntimeConfig, isCompacted: boolean): MemorySnapshotLimits;
+export declare function resolveSearchSnippetLimit(config: MemoryRuntimeConfig, isCompacted: boolean): number;
+/** Apply hit-count penalty so over-recalled refs sink in ranking (M9 dedup). */
+export declare function applyHitCountDedup(hits: LocalMemoryHit[], hitCounts: Map<string, number>, threshold: number): LocalMemoryHit[];
+export declare function loadMemoryHitCounts(db: Database, refs: string[]): Map<string, number>;
+export declare function bumpMemoryHitCounts(db: Database, refs: string[], nowSec: number): void;
+export declare function formatSnapshotLine(hit: LocalMemoryHit, snippetLimit: number): string;
+/** Trim snapshot lines to a total character budget without splitting refs mid-line. */
+export declare function applySnapshotCharacterBudget(lines: string[], maxChars: number): string[];
+export declare function clipMemoryText(text: string, limit: number): string;
+export declare function compactionSummaryExcerpt(entry: CompactionEntry | null, maxChars: number): string | undefined;
+export declare function defaultQualityConfig(): Pick<MemoryRuntimeConfig, "taskSnapshotTopN" | "taskSnapshotEpisodeCap" | "taskSnapshotMaxChars" | "searchMaxChars" | "snapshotSnippetChars" | "searchSnippetChars" | "hitCountDedupThreshold" | "compactedTaskSnapshotTopN" | "compactedTaskSnapshotEpisodeCap" | "compactedTaskSnapshotMaxChars" | "compactedSnapshotSnippetChars" | "compactedSearchSnippetChars" | "compactionContextMaxChars">;