@chude/memory 4.0.0

package/dist/infrastructure/sources/memory-file-scanner.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MemoryFileScanner
+ *
+ * Scans the legacy memory-file directory for markdown files.
+ *
+ * Discovers .md files, classifies their type from path patterns,
+ * extracts project encoded names, and computes content hashes.
+ * Returns empty array when the directory does not exist (graceful no-op).
+ *
+ * Implements the IMemoryFileScanner domain port.
+ */
+import type { IMemoryFileScanner, MemoryFileInfo } from "../../domain/ports/sources.js";
+export declare class MemoryFileScanner implements IMemoryFileScanner {
+    /**
+     * Discover all legacy memory files.
+     *
+     * @returns Array of discovered file info, empty if directory missing
+     */
+    discoverFiles(): Promise<MemoryFileInfo[]>;
+    private scanDirectory;
+    private classifyFileType;
+    private extractProjectEncoded;
+}

package/dist/infrastructure/sources/project-name-resolver.d.ts

@@ -0,0 +1,67 @@
+/**
+ * ProjectNameResolver
+ *
+ * Resolves correct project names from Claude Code's lossy encoded paths
+ * by walking the actual filesystem. Claude Code encodes backslashes,
+ * forward slashes, spaces, and hyphens all as single dashes, making
+ * reverse decoding ambiguous. This resolver uses the filesystem as
+ * source of truth to disambiguate.
+ *
+ * Algorithm:
+ * 1. Starting from the root directory, list actual subdirectories
+ * 2. For each subdirectory, encode its name (spaces/hyphens -> dashes)
+ * 3. Check if any encoded name is a prefix of the remaining encoded string
+ * 4. Consume the matched portion, descend into that directory
+ * 5. The last matched directory name is the project name
+ *
+ * Caches resolved prefixes to avoid redundant readdir calls.
+ */
+import type { IProjectNameResolver } from "../../domain/ports/sources.js";
+export declare class ProjectNameResolver implements IProjectNameResolver {
+    private readonly rootDir;
+    private readonly cache;
+    private readonly dirCache;
+    constructor(rootDir: string);
+    /**
+     * Resolve project name from a full encoded path including drive prefix.
+     * Strips Windows drive prefix (e.g., "C--") or Unix leading dash before resolving.
+     */
+    resolveFromEncodedPath(encodedPath: string): string;
+    /**
+     * Resolve the project name from an encoded path (without drive prefix).
+     * Walks the filesystem matching encoded segments against real directory names.
+     *
+     * @param encodedSegments - The encoded path without drive prefix (e.g., "Users-Destiny-Projects-memory-nexus")
+     * @returns The actual name of the last matched directory
+     */
+    resolveProjectName(encodedSegments: string): string;
+    /**
+     * Walk the filesystem recursively, matching encoded segments against
+     * actual directory names at each level.
+     */
+    private walkAndResolve;
+    /**
+     * Probe for hidden/virtual directories that readdirSync does not enumerate.
+     *
+     * Some directories (e.g., iCloudDrive on Windows) are valid and traversable
+     * but invisible to readdirSync. This method tries progressively longer
+     * dash-separated prefixes of the remaining encoded string as candidate
+     * directory names, checking each via statSync.
+     *
+     * @returns Resolved project name, or undefined if no hidden dir was found
+     */
+    private probeHiddenDirectories;
+    /**
+     * Check if a path is a directory. Handles virtual/hidden dirs that
+     * exist on disk but are not returned by readdirSync.
+     */
+    private isDirectory;
+    /**
+     * List subdirectories of a given path. Results are cached.
+     */
+    private listSubdirectories;
+    /**
+     * Fallback: extract last dash-separated segment (lossy behavior).
+     */
+    private fallbackLastSegment;
+}

package/dist/infrastructure/sources/session-source.d.ts

@@ -0,0 +1,70 @@
+/**
+ * FileSystemSessionSource
+ *
+ * Discovers Claude Code session files from the filesystem.
+ * Sessions are stored in ~/.claude/projects/<encoded-path>/<session-uuid>.jsonl
+ *
+ * Implements ISessionSource port for the infrastructure layer.
+ */
+import type { ISessionSource, SessionFileInfo } from "../../domain/ports/sources.js";
+import type { ProjectNameResolver } from "./project-name-resolver.js";
+/**
+ * Configuration options for FileSystemSessionSource
+ */
+export interface SessionSourceOptions {
+    /** Custom path to the Claude projects directory */
+    claudeDir?: string;
+    /** Resolver for fixing lossy project names via filesystem lookup */
+    projectNameResolver?: ProjectNameResolver;
+}
+/**
+ * Filesystem-based session source for Claude Code sessions.
+ *
+ * Scans the Claude Code projects directory structure to discover
+ * session JSONL files, including subagent sessions.
+ *
+ * Directory structure:
+ * ```
+ * ~/.claude/projects/
+ *   <encoded-path>/
+ *     <session-uuid>.jsonl          # Main session
+ *     <session-uuid>/
+ *       subagents/
+ *         <subagent-uuid>.jsonl     # Subagent session
+ * ```
+ */
+export declare class FileSystemSessionSource implements ISessionSource {
+    private readonly claudeProjectsDir;
+    private readonly resolver;
+    constructor(options?: SessionSourceOptions);
+    /**
+     * Discover all available session files.
+     *
+     * Scans the Claude Code projects directory recursively to find
+     * all JSONL session files, including subagent sessions.
+     *
+     * @returns Array of session file information
+     */
+    discoverSessions(): Promise<SessionFileInfo[]>;
+    /**
+     * Get the full path to a session file by ID.
+     *
+     * Searches all project directories for a session with the given ID.
+     *
+     * @param sessionId The session UUID
+     * @returns Full path to the JSONL file, or null if not found
+     */
+    getSessionFile(sessionId: string): Promise<string | null>;
+    /**
+     * Scan a project directory for session files.
+     *
+     * Finds both main session files and subagent sessions in subdirectories.
+     */
+    private scanProjectDirectory;
+    /**
+     * Scan a session directory for subagent session files.
+     *
+     * Looks for subagents/ subdirectory containing JSONL files.
+     */
+    private scanSubagentsDirectory;
+}

package/dist/presentation/cli/command-result.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CommandResult
+ *
+ * Return type for CLI command handlers. Commands return exit codes
+ * instead of mutating process.exitCode directly, keeping handlers
+ * pure and testable without global state.
+ */
+export interface CommandResult {
+    exitCode: number;
+}

package/dist/presentation/cli/commands/_helpers/capture-json.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared test helpers for .json.test.ts files (Plan 32-02).
+ *
+ * Captures stdout/stderr around a command invocation so envelope-shape
+ * assertions can be made deterministically. Used by all 6 query commands'
+ * .json.test.ts files (search/context/show/list/related/stats).
+ *
+ * Per Codex MEDIUM-3: no shell-specific assumptions; pure JS.
+ */
+export interface CapturedStreams {
+    stdout: string;
+    stderr: string;
+    exitCode?: number;
+}
+/**
+ * Capture stdout and stderr emitted by `fn` while it runs.
+ *
+ * Monkey-patches `console.log` and `console.error` for the duration
+ * of `fn`, then restores them. Returns concatenated output and the
+ * function's `exitCode` (if returned).
+ *
+ * Single-line outputs are concatenated with newlines.
+ */
+export declare function captureStreams<R extends {
+    exitCode?: number;
+} | undefined>(fn: () => Promise<R>): Promise<CapturedStreams>;
+/**
+ * Per-test temp DB path tracker. Returns a path + a cleanup hook.
+ *
+ * Pattern:
+ *   const tempPaths: string[] = [];
+ *   const dbPath = makeTempDbPath("search", tempPaths);
+ *   afterEach(() => cleanupTempPaths(tempPaths));
+ */
+export declare function makeTempDbPath(cmd: string, tracker: string[]): string;
+export declare function cleanupTempPaths(tracker: string[]): void;

package/dist/presentation/cli/commands/_helpers/deprecation-warning.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Phase 32 (CLI-03) deprecation-warning helper.
+ *
+ * Emits a one-shot stderr warning when a deprecated `--format` alias
+ * value is passed. Suppressed in `--json` mode so the JSON-on-stdout
+ * contract isn't polluted by advisory stderr.
+ *
+ * Module-scoped Set tracks emissions per process to prevent log
+ * floods if a CLI invocation calls into a command multiple times
+ * (e.g. tests that share the module). The Set key is the command
+ * + alias pair, so each unique deprecated alias warns once per
+ * process.
+ *
+ * Precedence rule (matches Plan 32-02 Codex HIGH-5 contract):
+ *   --quiet ≥ brief; --json suppresses warning (already on stdout).
+ *
+ * Removal: aliases `default` (search/list/show/stats) and `detailed`
+ * (context/related) are scheduled for removal in the next minor
+ * release. CHANGELOG.md documents the cadence.
+ */
+export interface EmitDeprecationOptions {
+    /** Command name (e.g. "search"). Used as part of the once-key. */
+    command: string;
+    /** The deprecated alias value seen (e.g. "default" or "detailed"). */
+    alias: string;
+    /** Suggested replacement message (e.g. "Use --format brief or --format ai."). */
+    replacement: string;
+    /**
+     * Whether --json is set; if true, warning is suppressed.
+     * Explicit `undefined` allowed because callers commonly pass the
+     * `options.json` value directly (project uses
+     * `exactOptionalPropertyTypes: true`).
+     */
+    json?: boolean | undefined;
+}
+export declare function emitFormatDeprecationWarning(options: EmitDeprecationOptions): void;
+/**
+ * Reset emitted-keys tracker. Test-only — production code does not
+ * call this. Allows per-test isolation of one-shot semantics.
+ */
+export declare function resetFormatDeprecationWarningsForTesting(): void;

package/dist/presentation/cli/commands/backfill.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Backfill Command Handler
+ *
+ * CLI command for generating daily log entries from historical sessions
+ * via claude -p. Provides dry-run preview, confirmation prompt, progress bar,
+ * and project/batch filtering.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+import type { BackfillOptions, BackfillResult, DryRunResult, IDailyLogWriter } from "../../../application/services/backfill-service.js";
+/**
+ * Options parsed from the CLI.
+ */
+export interface BackfillCommandOptions {
+    dryRun?: boolean;
+    project?: string;
+    batch: string;
+    force?: boolean;
+    writeMemoryFiles?: boolean;
+}
+/**
+ * Service interface for dependency injection in tests.
+ */
+export interface BackfillServiceDeps {
+    dryRun(options?: {
+        project?: string | undefined;
+    }): Promise<DryRunResult>;
+    backfill(options?: BackfillOptions): Promise<BackfillResult>;
+}
+export interface BackfillExecutionDeps {
+    confirm?: (message: string) => Promise<boolean>;
+    createProgressBar?: (total: number) => Promise<{
+        start: Function;
+        update: Function;
+        stop: Function;
+    } | null>;
+}
+/**
+ * Daily log writer implementation.
+ *
+ * Writes or appends legacy daily log entries to the memory-file root.
+ * Creates parent directories if needed.
+ */
+export declare class FileDailyLogWriter implements IDailyLogWriter {
+    private readonly memoryDir;
+    constructor(memoryDir: string);
+    writeOrAppend(datePath: string, content: string): Promise<boolean>;
+}
+/**
+ * Execute the backfill command programmatically.
+ *
+ * Separated from createBackfillCommand for testability.
+ * Tests inject mock BackfillServiceDeps; CLI injects real ones.
+ */
+export declare function executeBackfillCommand(options: BackfillCommandOptions, service: BackfillServiceDeps, deps?: BackfillExecutionDeps): Promise<CommandResult>;
+export declare function createBackfillCommand(): Command;

package/dist/presentation/cli/commands/browse.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Browse Command Handler
+ *
+ * CLI command for interactive session browsing.
+ * Launches picker UI and dispatches to appropriate command based on action.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+import { executeShowCommand } from "./show.js";
+import { executeSearchCommand } from "./search.js";
+import { executeContextCommand } from "./context.js";
+import { executeRelatedCommand } from "./related.js";
+/**
+ * Options for the browse command.
+ */
+export interface BrowseCommandOptions {
+    /** Maximum sessions to show in the picker (as string, parsed to integer) */
+    limit?: string;
+}
+/**
+ * Runtime dependencies for executeBrowseCommand.
+ *
+ * Operational dependencies that tests substitute for isolation. Keeps
+ * dispatch targets injectable without `mock.module()` (which is
+ * process-wide in Bun and leaks across test files).
+ */
+export interface BrowseCommandDeps {
+    /** Database path. Defaults to getDefaultDbPath(). */
+    dbPath?: string;
+    /** Show command dispatcher. Defaults to the real implementation. */
+    show?: typeof executeShowCommand;
+    /** Search command dispatcher. Defaults to the real implementation. */
+    search?: typeof executeSearchCommand;
+    /** Context command dispatcher. Defaults to the real implementation. */
+    context?: typeof executeContextCommand;
+    /** Related command dispatcher. Defaults to the real implementation. */
+    related?: typeof executeRelatedCommand;
+}
+/**
+ * Create the browse command for Commander.js.
+ *
+ * @returns Configured Command instance
+ */
+export declare function createBrowseCommand(): Command;
+/**
+ * Execute the browse command programmatically.
+ *
+ * Interactively browse sessions using fuzzy search. Requires an
+ * interactive TTY; will return exitCode 1 in non-interactive environments.
+ * Handles its own database initialization and teardown.
+ *
+ * @param options - Browse command options
+ * @returns CommandResult with exitCode 0 (success) or 1 (not available/error)
+ */
+export declare function executeBrowseCommand(options: BrowseCommandOptions, deps?: BrowseCommandDeps): Promise<CommandResult>;

package/dist/presentation/cli/commands/completion.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Completion Command Handler
+ *
+ * CLI command for generating shell completion scripts for bash, zsh, and fish.
+ * Users can eval or source these scripts to enable tab-completion for the CLI.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+/**
+ * Supported shell types for completion generation.
+ */
+export type ShellType = "bash" | "zsh" | "fish";
+/**
+ * Check if a string is a valid shell type.
+ *
+ * @param shell String to check
+ * @returns True if shell is a valid ShellType
+ */
+export declare function isValidShell(shell: string): shell is ShellType;
+/**
+ * Generate bash completion script.
+ *
+ * @returns Bash completion script string
+ */
+export declare function generateBashCompletion(): string;
+/**
+ * Generate zsh completion script.
+ *
+ * @returns Zsh completion script string
+ */
+export declare function generateZshCompletion(): string;
+/**
+ * Generate fish completion script.
+ *
+ * @returns Fish completion script string
+ */
+export declare function generateFishCompletion(): string;
+/**
+ * Generate completion script for the specified shell.
+ *
+ * @param shell Shell type (bash, zsh, or fish)
+ * @returns Completion script string
+ * @throws Error if shell type is invalid
+ */
+export declare function generateCompletion(shell: ShellType): string;
+/**
+ * Create the completion command for Commander.js.
+ *
+ * @returns Configured Command instance
+ */
+export declare function createCompletionCommand(): Command;
+/**
+ * Execute the completion command programmatically.
+ *
+ * Outputs a shell completion script for the specified shell type.
+ * Supported shells: bash, zsh, fish.
+ *
+ * @param shell - Shell type (bash, zsh, or fish)
+ * @returns CommandResult with exitCode 0 (success) or 1 (invalid shell)
+ */
+export declare function executeCompletionCommand(shell: string): CommandResult;

package/dist/presentation/cli/commands/context.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Context Command Handler
+ *
+ * CLI command for showing aggregated context for a project.
+ * Supports filtering by days, token budgets, cross-project mode,
+ * and multiple output formats including AI-optimized output.
+ *
+ * When --format ai, --budget, or --cross-project is set, uses
+ * SmartContextService for structured briefings from memory files.
+ * Otherwise falls back to legacy SqliteContextService for backward
+ * compatibility.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+/**
+ * Options for the context command.
+ */
+export interface ContextCommandOptions {
+    /** Sessions from last N days (includes today) */
+    days?: number;
+    /**
+     * Output format. Phase 32 (CLI-03) normalized choices: `brief`,
+     * `ai`. `detailed` retained as deprecated alias (one-minor cadence;
+     * CHANGELOG documents removal). Undefined = no-flag default
+     * (existing brief behavior preserved for backward compatibility).
+     */
+    format?: "brief" | "ai" | "detailed";
+    /** Maximum token budget for smart context */
+    budget?: number;
+    /** Include cross-project learnings and decisions */
+    crossProject?: boolean;
+    /** Output as JSON */
+    json?: boolean;
+    /** Show detailed output with timing */
+    verbose?: boolean;
+    /** Minimal output */
+    quiet?: boolean;
+    /** Override database path (for testing) */
+    dbPath?: string;
+}
+/**
+ * Create the context command for Commander.js.
+ *
+ * @returns Configured Command instance
+ */
+export declare function createContextCommand(): Command;
+export declare function executeContextCommand(project: string, options: ContextCommandOptions): Promise<CommandResult>;
+/**
+ * Internal implementation of the context query execution.
+ */
+export declare function runContextInternal(project: string, options: ContextCommandOptions, deps?: {
+    dbPath?: string;
+}): Promise<CommandResult>;

package/dist/presentation/cli/commands/doctor.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Doctor Command Handler (Wrapper)
+ *
+ * Thin view that delegates health checks and diagnostics to executeStatusCommand.
+ * Maintained for backwards compatibility.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+import type { GatherStatusOptions, StatusInfo } from "./status.js";
+import type { HealthCheckResult } from "../../../infrastructure/database/health-checker.js";
+/**
+ * Options for the doctor command.
+ */
+export interface DoctorOptions {
+    /** Output health check results as JSON */
+    json?: boolean;
+    /** Attempt to fix common issues automatically */
+    fix?: boolean;
+    /** Perform portability diagnostics */
+    portability?: boolean;
+}
+/**
+ * Runtime dependencies for executeDoctorCommand.
+ */
+export interface DoctorCommandDeps {
+    healthOverrides?: {
+        dbPath?: string;
+        configDir?: string;
+        logsDir?: string;
+        sourceDir?: string;
+        hookOverrides?: import("../../../infrastructure/hooks/settings-manager.js").PathOverrides;
+    };
+    gatherStatus?: (options: GatherStatusOptions) => Promise<StatusInfo>;
+}
+/**
+ * Format health check result as readable output.
+ */
+export declare function formatHealthResult(result: HealthCheckResult, useColor: boolean): string;
+/**
+ * Attempt automatic fixes for common issues.
+ */
+export declare function attemptFixes(result: HealthCheckResult, useColor: boolean): string[];
+/**
+ * Create the doctor command for Commander.js.
+ */
+export declare function createDoctorCommand(): Command;
+/**
+ * Execute the doctor command programmatically by wrapping executeStatusCommand.
+ */
+export declare function executeDoctorCommand(options: DoctorOptions, deps?: DoctorCommandDeps): Promise<CommandResult>;
+export declare function isMixedPathDialect(decoded: string, platform?: NodeJS.Platform): boolean;
+/**
+ * Execute portability diagnostics for environment transitions.
+ */
+export declare function runPortabilityDiagnostics(options: DoctorOptions, deps?: DoctorCommandDeps): Promise<CommandResult>;

package/dist/presentation/cli/commands/export.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Export Command Handler
+ *
+ * CLI command for exporting the database to a JSON backup file.
+ * Supports quiet mode and JSON output for scripting.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+/**
+ * Options for the export command.
+ */
+export interface ExportOptions {
+    /** Suppress output except the file path */
+    quiet?: boolean;
+    /** Output stats as JSON */
+    json?: boolean;
+    /** Export raw sensitive values instead of redacting known secret patterns */
+    includeSensitive?: boolean;
+}
+/**
+ * Create the export command for Commander.js.
+ *
+ * @returns Configured Command instance
+ */
+export declare function createExportCommand(): Command;
+/**
+ * Execute the export command programmatically.
+ *
+ * Exports the database to a JSON backup file. Handles its own database
+ * initialization and teardown.
+ *
+ * @param outputFile - Destination file path for the JSON backup
+ * @param options - Export command options
+ * @returns CommandResult with exitCode 0 (success) or 1 (error)
+ */
+export declare function executeExportCommand(outputFile: string, options?: ExportOptions): Promise<CommandResult>;

package/dist/presentation/cli/commands/extract.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Extract CLI Command Handler
+ *
+ * Runs the comparative LLM fact extraction pipeline on session history.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+import { type MemoryConfig } from "../../../infrastructure/hooks/config-manager.js";
+import type { IExtractionProvider } from "../../../domain/ports/extraction.js";
+import type { IEmbeddingProvider } from "../../../domain/ports/embedding.js";
+export interface ExtractCommandOptions {
+    project: string;
+    all?: boolean;
+    since?: string;
+    force?: boolean;
+    json?: boolean;
+    quiet?: boolean;
+}
+export interface ExtractCommandDeps {
+    dbPath?: string;
+    mockExtractor?: IExtractionProvider;
+    mockEmbedder?: IEmbeddingProvider;
+    createEmbedder?: (config: MemoryConfig) => Promise<IEmbeddingProvider | undefined>;
+    eventLogPath?: string;
+}
+/**
+ * Custom Progress indicator for fact extraction.
+ */
+export declare class ExtractProgress {
+    private current;
+    private total;
+    private isTty;
+    private quiet;
+    constructor(total: number, quiet?: boolean);
+    update(sessionName: string): void;
+    stop(): void;
+}
+export declare function createDefaultEmbedder(config: MemoryConfig): Promise<IEmbeddingProvider | undefined>;
+export declare function createExtractCommand(): Command;
+export declare function executeExtractCommand(options: ExtractCommandOptions, deps?: ExtractCommandDeps): Promise<CommandResult>;

package/dist/presentation/cli/commands/facts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Facts CLI Command Handler
+ *
+ * Displays active project facts or full historical lineages including superseded updates.
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../command-result.js";
+export interface FactsCommandOptions {
+    project: string;
+    superseded?: boolean;
+    json?: boolean;
+}
+export interface FactsCommandDeps {
+    dbPath?: string;
+}
+export declare function createFactsCommand(): Command;
+export declare function executeFactsCommand(options: FactsCommandOptions, deps?: FactsCommandDeps): Promise<CommandResult>;

package/dist/presentation/cli/commands/friction/dashboard.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Friction Dashboard Handler
+ *
+ * Handles the friction dashboard subcommand.
+ * Supports terminal, HTML, and JSON output modes.
+ */
+import type { CommandResult } from "../../command-result.js";
+import type { FrictionExecuteOptions, BrowserOpener } from "./types.js";
+import type { FrictionService } from "../../../../application/services/friction-service.js";
+/**
+ * Handle the dashboard action.
+ *
+ * Three modes:
+ * - Default: Rich terminal output via formatFrictionDashboard
+ * - --html: Generate self-contained HTML file and open in browser
+ * - --json: Output stats and trends as JSON
+ */
+export declare function handleDashboard(service: FrictionService, options: FrictionExecuteOptions, openFn?: BrowserOpener): Promise<CommandResult>;

package/dist/presentation/cli/commands/friction/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Friction command group: log, list, resolve, wont-fix, dashboard, purge.
+ * Each subcommand defines --json independently (Commander.js does not inherit parent options).
+ */
+import { Command } from "commander";
+import type { CommandResult } from "../../command-result.js";
+import type { FrictionExecuteOptions, FrictionCommandDeps } from "./types.js";
+/** Create the friction command group for Commander.js. */
+export declare function createFrictionCommand(): Command;
+/** Execute a friction command programmatically. Manages DB lifecycle, dispatches to handlers. */
+export declare function executeFrictionCommand(options: FrictionExecuteOptions, deps?: FrictionCommandDeps): Promise<CommandResult>;
+export type { BrowserOpener, FrictionCommandDeps, FrictionCommandOptions, FrictionLogOptions, FrictionListOptions, FrictionResolveOptions, FrictionPurgeOptions, FrictionExecuteOptions, } from "./types.js";