/**
 * `shieldcortex remember "<title>" --content "<text>" [options]` (Phase 15c)
 *
 * A real, non-hanging CLI write command. The historical gotcha — "remember CLI
 * hangs, avoid until fixed" — was that no such subcommand existed; any lookalike
 * path blocked on a stdio/TTY transport. This command writes a memory directly
 * through the SAME store path the MCP `remember` tool uses (executeRemember), so
 * the defence pipeline + project scoping + dedupe all apply, then EXITS cleanly.
 *
 * Anti-hang contract: content comes from `--content`, else from PIPED stdin.
 * If neither is present (an interactive TTY with no flag), we print usage and
 * exit non-zero rather than blocking on a read that would never resolve.
 *
 * Layering:
 *   - `runRemember` is the pure core: takes resolved options, returns a
 *     structured result. No argv, no process.exit, no stdin — fully testable.
 *   - `resolveRememberContent` isolates the stdin/TTY decision so the anti-hang
 *     behaviour can be asserted without a real terminal.
 *   - `handleRememberCommand` is the thin CLI wrapper: parse argv, resolve
 *     content, run, print, drain cloud sync, close DB, exit.
 */
import { type RememberInput } from '../tools/remember.js';
type Importance = 'low' | 'medium' | 'high';
export interface RememberOptions {
    title: string;
    content: string;
    category?: string;
    importance?: Importance;
    tags?: string[];
    project?: string;
    /** Flat source type — defaults to a `cli` source so interactive writes stay uncapped. */
    sourceType?: RememberInput['sourceType'];
    sourceIdentifier?: string;
}
export interface RememberResult {
    success: boolean;
    memory?: {
        id: number;
        title: string;
        salience: number;
        type: string;
        category: string;
    };
    error?: string;
}
/**
 * Pure write core. Delegates entirely to executeRemember so the defence
 * pipeline, project auto-scoping, dedupe and salience handling are reused
 * verbatim — there is no second implementation to drift.
 */
export declare function runRemember(opts: RememberOptions): Promise<RememberResult>;
/**
 * Resolve the memory content from the flag or piped stdin WITHOUT ever blocking
 * on a TTY. `readStdin` is injected so this is unit-testable.
 *
 * Precedence: explicit --content > piped stdin > usage error.
 */
export declare function resolveRememberContent(args: {
    contentFlag: string | undefined;
    isTTY: boolean;
    readStdin: () => Promise<string>;
}): Promise<{
    ok: true;
    content: string;
} | {
    ok: false;
    usage: boolean;
}>;
/**
 * CLI entry point. Parses argv, resolves content (flag or piped stdin, never a
 * TTY block), runs the write, prints a concise human or --json result, drains
 * any in-flight cloud sync, closes the DB to release handles, and exits.
 */
export declare function handleRememberCommand(args: string[]): Promise<void>;
export {};
