zam-core 0.3.6 → 0.3.11

package/dist/index.d.ts

@@ -1,4 +1,40 @@
-import { Database } from 'libsql';
+type DatabaseValue = string | number | bigint | null | Uint8Array;
+interface RunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+/**
+ * Asynchronous database contract used by the learning kernel.
+ *
+ * Every provider (local SQLite, optional libsql embedded replica, remote
+ * Turso over HTTP) implements this interface; no kernel or public API type
+ * depends on a concrete database package.
+ */
+interface Statement {
+    run(...params: unknown[]): Promise<RunResult>;
+    get(...params: unknown[]): Promise<unknown>;
+    all(...params: unknown[]): Promise<unknown[]>;
+}
+interface Database {
+    prepare(sql: string): Statement;
+    /** Execute one or more SQL statements without reading results. */
+    exec(sql: string): Promise<void>;
+    /**
+     * Run a PRAGMA. Local providers support the full pragma surface; the
+     * remote provider only supports read pragmas that have a table-valued
+     * function equivalent (e.g. `table_info(...)`).
+     */
+    pragma(source: string): Promise<unknown>;
+    /**
+     * Run `fn` inside a BEGIN IMMEDIATE … COMMIT/ROLLBACK transaction.
+     * Transactions are serialized per connection; nested calls deadlock by
+     * design rather than silently interleaving writes.
+     */
+    transaction<T>(fn: (db: Database) => Promise<T>): Promise<T>;
+    /** Pull changes from the cloud primary (embedded replicas only). */
+    sync?(): Promise<void>;
+    close(): Promise<void>;
+}
 
 /**
  * Learning Analytics
@@ -29,12 +65,12 @@ interface DomainCompetence {
 /**
  * Get overall learning stats for a user (ported from PoC's `stats` command).
  */
-declare function getUserStats(db: Database, userId: string): UserStats;
+declare function getUserStats(db: Database, userId: string): Promise<UserStats>;
 /**
  * Get competence per domain for a user.
  * Used to suggest symbiosis mode transitions.
  */
-declare function getDomainCompetence(db: Database, userId: string): DomainCompetence[];
+declare function getDomainCompetence(db: Database, userId: string): Promise<DomainCompetence[]>;
 
 /**
  * Azure DevOps connector — fetches work items from ADO boards.
@@ -70,6 +106,11 @@ declare function fetchActiveWorkItems(config: ADOConfig): Promise<WorkItem[]>;
 interface TursoCredentials {
     url: string;
     token: string;
+    /**
+     * Database access mode: "native" uses the legacy libsql driver, "remote"
+     * uses the HTTP provider (no native bindings; required on Windows ARM64).
+     */
+    mode?: "native" | "remote";
 }
 interface ADOCredentials {
     org_url: string;
@@ -87,7 +128,7 @@ declare function saveCredentials(creds: Credentials, path?: string): void;
 /** Get complete Turso credentials, or null if incomplete. */
 declare function getTursoCredentials(path?: string): TursoCredentials | null;
 /** Set Turso credentials. */
-declare function setTursoCredentials(url: string, token: string, path?: string): void;
+declare function setTursoCredentials(url: string, token: string, path?: string, mode?: TursoCredentials["mode"]): void;
 /** Clear Turso credentials. */
 declare function clearTursoCredentials(path?: string): void;
 /** Get complete ADO credentials, or null if incomplete. */
@@ -97,10 +138,16 @@ declare function setADOCredentials(orgUrl: string, project: string, pat: string,
 /** Clear ADO credentials. */
 declare function clearADOCredentials(path?: string): void;
 
+/**
+ * - `local`: better-sqlite3 file database (default without cloud credentials)
+ * - `native`: legacy native libsql driver (remote URLs and embedded replicas)
+ * - `remote`: Turso over HTTP, no native bindings (works on Windows ARM64)
+ */
+type DatabaseProvider = "local" | "native" | "remote";
 interface ConnectionOptions {
     /** Path to the SQLite database file. Defaults to ~/.zam/zam.db */
     dbPath?: string;
-    /** If true, create the directory and run schema migrations on open */
+    /** If true, run the schema even when the database already exists. */
     initialize?: boolean;
     /** Turso sync URL for embedded replica mode (e.g. libsql://db-name.turso.io) */
     syncUrl?: string;
@@ -108,6 +155,8 @@ interface ConnectionOptions {
     authToken?: string;
     /** If false, ignore ~/.zam/credentials.json and force the local/default database. */
     useConfiguredCloud?: boolean;
+    /** Explicit provider; overrides ZAM_DB_PROVIDER and the credentials mode. */
+    provider?: DatabaseProvider;
 }
 /**
  * Open (or create) the ZAM database.
@@ -115,17 +164,110 @@ interface ConnectionOptions {
  * Falls back to local SQLite and WAL mode when no cloud credentials exist.
  * When syncUrl is provided explicitly, enables embedded replica sync with Turso.
  */
-declare function openDatabase(options?: ConnectionOptions): Database;
+declare function openDatabase(options?: ConnectionOptions): Promise<Database>;
 /**
  * Open the database with Turso cloud credentials auto-detected.
  * Credentials live in ~/.zam/credentials.json (NOT in the db), so a fresh
  * machine only has to collect missing secrets instead of bootstrapping local
  * state first.
  */
-declare function openDatabaseWithSync(options?: Omit<ConnectionOptions, "syncUrl" | "authToken">): Database;
+declare function openDatabaseWithSync(options?: Omit<ConnectionOptions, "syncUrl" | "authToken">): Promise<Database>;
 /** Get the default database path */
 declare function getDefaultDbPath(): string;
 
+/**
+ * Minimal Hrana v3 over HTTP transport for Turso/libsql servers.
+ *
+ * Implements exactly the subset ZAM needs — execute, sequence, close, and
+ * baton-scoped streams for transactions — over plain `fetch`, so it runs on
+ * every architecture Node.js supports (including Windows ARM64, which has no
+ * native libsql binding).
+ *
+ * Protocol reference: https://github.com/tursodatabase/libsql/blob/main/docs/HRANA_3_SPEC.md
+ */
+interface HranaTransportOptions {
+    /** Database URL (libsql://, https:// or http://). */
+    url: string;
+    /** Turso auth token; omitted for unauthenticated local servers. */
+    authToken?: string;
+    /** Per-request timeout in milliseconds. */
+    timeoutMs?: number;
+    /**
+     * Total attempts for requests that failed at the transport level before a
+     * response was received. Stateful stream requests (open batons) are never
+     * retried.
+     */
+    maxAttempts?: number;
+}
+
+/**
+ * RemoteTursoProvider — implements the async `Database` contract directly
+ * against a Turso/libsql server over HTTP (Hrana v3).
+ *
+ * No native bindings and no extra runtime dependencies, so this provider is
+ * the cloud path for architectures without a native libsql artifact (for
+ * example Windows ARM64). Under ZAM's online-first assumption it is suitable
+ * for interactive sessions: the per-review LLM call dominates latency.
+ */
+
+type RemoteDatabaseOptions = HranaTransportOptions;
+/** Open a remote Turso database over HTTP. */
+declare function openRemoteDatabase(options: RemoteDatabaseOptions): Database;
+
+/**
+ * Portable database snapshots — Increment 12, Phase 4.
+ *
+ * A snapshot is portable SQL text: a one-line JSON manifest comment followed by
+ * `INSERT` statements for every data row. It deliberately does NOT copy the
+ * live WAL database file, so a user can move their learning history between
+ * machines through a file-sync folder (Google Drive, OneDrive, iCloud, …)
+ * without risking the corruption that comes from syncing an open SQLite/WAL
+ * file directly.
+ *
+ * The schema is NOT embedded. Importing into a freshly initialized database —
+ * which always runs the current SCHEMA + migrations on open — keeps snapshots
+ * forward compatible across schema changes. Columns are written explicitly so a
+ * later-added column never breaks an older snapshot.
+ */
+
+declare const SNAPSHOT_VERSION = 1;
+interface SnapshotManifest {
+    format: string;
+    version: number;
+    createdAt: string;
+    /** Row count per table at export time. */
+    tables: Record<string, number>;
+    /** SHA-256 of the snapshot body (everything after the manifest line). */
+    checksum: string;
+}
+interface ImportResult {
+    /** Row count per table after the restore. */
+    tables: Record<string, number>;
+    total: number;
+}
+/**
+ * Serialize the active database to a portable SQL-text snapshot.
+ */
+declare function exportSnapshot(db: Database, options?: {
+    createdAt?: string;
+}): Promise<string>;
+/** Split a snapshot into its manifest and body; validates the header only. */
+declare function parseSnapshot(snapshot: string): {
+    manifest: SnapshotManifest;
+    body: string;
+};
+/** Parse a snapshot and verify its body checksum. Returns the manifest. */
+declare function verifySnapshot(snapshot: string): SnapshotManifest;
+/**
+ * Restore a snapshot into `db`. The database must already carry the current
+ * schema (open it with `initialize: true`). Refuses to overwrite a non-empty
+ * database unless `force` is set, and verifies row counts inside the
+ * transaction so any mismatch rolls the whole restore back.
+ */
+declare function importSnapshot(db: Database, snapshot: string, options?: {
+    force?: boolean;
+}): Promise<ImportResult>;
+
 /**
  * Goal file parser — reads markdown files with YAML-style frontmatter.
  *
@@ -267,9 +409,9 @@ interface CreateAgentSkillInput {
     token_slugs?: string[];
     source?: SkillSource;
 }
-declare function createAgentSkill(db: Database, input: CreateAgentSkillInput): AgentSkill;
-declare function getAgentSkill(db: Database, slug: string): AgentSkill | undefined;
-declare function listAgentSkills(db: Database): AgentSkill[];
+declare function createAgentSkill(db: Database, input: CreateAgentSkillInput): Promise<AgentSkill>;
+declare function getAgentSkill(db: Database, slug: string): Promise<AgentSkill | undefined>;
+declare function listAgentSkills(db: Database): Promise<AgentSkill[]>;
 
 /**
  * Card repository — typed wrappers around the cards table.
@@ -335,30 +477,30 @@ interface BlockedCard extends Card {
  *
  * Ported from the PoC's ensureCard helper.
  */
-declare function ensureCard(db: Database, tokenId: string, userId: string): Card;
+declare function ensureCard(db: Database, tokenId: string, userId: string): Promise<Card>;
 /**
  * Get a card by token+user. Returns undefined if no card exists.
  */
-declare function getCard(db: Database, tokenId: string, userId: string): Card | undefined;
+declare function getCard(db: Database, tokenId: string, userId: string): Promise<Card | undefined>;
 /**
  * Get a card by its ULID.
  */
-declare function getCardById(db: Database, cardId: string): Card | undefined;
+declare function getCardById(db: Database, cardId: string): Promise<Card | undefined>;
 /**
  * Update a card's scheduling fields.
  *
  * Only the fields present in `updates` are changed. Throws if the card
  * does not exist.
  */
-declare function updateCard(db: Database, cardId: string, updates: UpdateCardInput): Card;
+declare function updateCard(db: Database, cardId: string, updates: UpdateCardInput): Promise<Card>;
 /**
  * Preview the review-log rows that will be removed when deleting a user's card.
  */
-declare function getCardDeletionImpact(db: Database, tokenId: string, userId: string): CardDeletionImpact;
+declare function getCardDeletionImpact(db: Database, tokenId: string, userId: string): Promise<CardDeletionImpact>;
 /**
  * Delete one user's card for a token. Review logs cascade via FK.
  */
-declare function deleteCardForUser(db: Database, tokenId: string, userId: string): DeleteCardResult;
+declare function deleteCardForUser(db: Database, tokenId: string, userId: string): Promise<DeleteCardResult>;
 /**
  * Get all cards that are due for review.
  *
@@ -368,19 +510,20 @@ declare function deleteCardForUser(db: Database, tokenId: string, userId: string
  *
  * Ported from the PoC's due-tokens command.
  */
-declare function getDueCards(db: Database, userId: string, now?: string): DueCard[];
+declare function getDueCards(db: Database, userId: string, now?: string): Promise<DueCard[]>;
 /**
  * Get all blocked cards for a user.
  *
  * Returns cards joined with their token details so the caller can
  * see what is waiting and why.
  */
-declare function getBlockedCards(db: Database, userId: string): BlockedCard[];
+declare function getBlockedCards(db: Database, userId: string): Promise<BlockedCard[]>;
 
 /**
  * Prerequisite repository — typed wrappers around the prerequisites table.
  *
  * Models the dependency graph: "to learn token A, first know token B."
+ * The graph must remain acyclic — cycles are rejected at insert time.
  */
 
 interface Prerequisite {
@@ -394,26 +537,69 @@ interface PrerequisiteWithToken extends Prerequisite {
     domain: string;
     bloom_level: number;
 }
+/**
+ * Returns true if adding edge (tokenId → requiresId) would create a cycle.
+ * Uses BFS from requiresId: if tokenId is reachable, adding the edge closes
+ * a loop.
+ */
+declare function wouldCreateCycle(db: Database, tokenId: string, requiresId: string): Promise<boolean>;
 /**
  * Add a prerequisite edge: tokenId requires requiresId.
  *
  * Idempotent — silently ignores duplicate edges.
  * Throws if either token ID does not exist (FK constraint).
  * Throws if a token is declared as its own prerequisite.
+ * Throws if the edge would create a cycle in the prerequisite graph.
  */
-declare function addPrerequisite(db: Database, tokenId: string, requiresId: string): void;
+declare function addPrerequisite(db: Database, tokenId: string, requiresId: string): Promise<void>;
 /**
  * Get the direct prerequisites of a token — "what does token X require?"
  *
  * Returns prerequisite rows joined with the required token's details.
  */
-declare function getPrerequisites(db: Database, tokenId: string): PrerequisiteWithToken[];
+declare function getPrerequisites(db: Database, tokenId: string): Promise<PrerequisiteWithToken[]>;
 /**
  * Get the direct dependents of a token — "what depends on token X?"
  *
  * Returns prerequisite rows joined with the dependent token's details.
  */
-declare function getDependents(db: Database, tokenId: string): PrerequisiteWithToken[];
+declare function getDependents(db: Database, tokenId: string): Promise<PrerequisiteWithToken[]>;
+/** Token + optional per-user card snapshot, tailored for visual encoding (mastery, blocked state, bloom). */
+interface NeighborhoodToken {
+    id: string;
+    slug: string;
+    concept: string;
+    domain: string;
+    bloom_level: number;
+    card: {
+        state: CardState$1;
+        reps: number;
+        stability: number;
+        difficulty: number;
+        blocked: boolean;
+        due_at: string;
+        last_review_at: string | null;
+    } | null;
+}
+/**
+ * The direct neighborhood for a focus-centric 3D view:
+ * - center: the token in focus
+ * - prerequisites: direct "basis" tokens required by the center (foundations, placed "below")
+ * - dependents: direct tokens that require the center (higher-order abilities, placed "above")
+ *
+ * When userId is supplied, every node includes the user's Card state so the viz can
+ * encode personal mastery (e.g. color by stability/reps, highlight blocked or due).
+ */
+interface Neighborhood {
+    center: NeighborhoodToken;
+    prerequisites: NeighborhoodToken[];
+    dependents: NeighborhoodToken[];
+}
+/**
+ * Fetch the direct (depth-1) prerequisite neighborhood around one token.
+ * This is the primary data source for the experimental 3D knowledge graph.
+ */
+declare function getTokenNeighborhood(db: Database, tokenId: string, userId?: string): Promise<Neighborhood>;
 
 /**
  * Review log repository — typed wrappers around the review_logs table.
@@ -457,17 +643,17 @@ interface ListReviewsOptions {
  * Validates that the rating is between 1 and 4 (matching the schema CHECK).
  * Returns the created review log entry.
  */
-declare function logReview(db: Database, input: CreateReviewInput): ReviewLog;
+declare function logReview(db: Database, input: CreateReviewInput): Promise<ReviewLog>;
 /**
  * Get all reviews for a specific card, ordered by reviewed_at ascending.
  */
-declare function getReviewsForCard(db: Database, cardId: string): ReviewLog[];
+declare function getReviewsForCard(db: Database, cardId: string): Promise<ReviewLog[]>;
 /**
  * Get reviews for a user, with optional filtering.
  *
  * Results are ordered by reviewed_at descending (most recent first).
  */
-declare function getReviewsForUser(db: Database, userId: string, options?: ListReviewsOptions): ReviewLog[];
+declare function getReviewsForUser(db: Database, userId: string, options?: ListReviewsOptions): Promise<ReviewLog[]>;
 
 /**
  * Session repository — typed wrappers around sessions and session_steps.
@@ -522,7 +708,7 @@ interface SessionSummary {
  *
  * Ported from the PoC's start-session command.
  */
-declare function startSession(db: Database, input: CreateSessionInput): Session;
+declare function startSession(db: Database, input: CreateSessionInput): Promise<Session>;
 /**
  * End a session by setting its completed_at timestamp.
  *
@@ -530,7 +716,7 @@ declare function startSession(db: Database, input: CreateSessionInput): Session;
  *
  * Ported from the PoC's end-session command.
  */
-declare function endSession(db: Database, sessionId: string): Session;
+declare function endSession(db: Database, sessionId: string): Promise<Session>;
 /**
  * Log a step within a session.
  *
@@ -539,7 +725,7 @@ declare function endSession(db: Database, sessionId: string): Session;
  *
  * Ported from the PoC's log-step command.
  */
-declare function logStep(db: Database, input: LogStepInput): SessionStep;
+declare function logStep(db: Database, input: LogStepInput): Promise<SessionStep>;
 /**
  * Get a full session summary: the session record plus all steps
  * joined with their token details.
@@ -547,7 +733,7 @@ declare function logStep(db: Database, input: LogStepInput): SessionStep;
  * Ported from the PoC's session-summary command.
  * Throws if the session does not exist.
  */
-declare function getSessionSummary(db: Database, sessionId: string): SessionSummary;
+declare function getSessionSummary(db: Database, sessionId: string): Promise<SessionSummary>;
 
 /**
  * User settings — key/value store backed by the user_config table.
@@ -559,15 +745,15 @@ interface UserSetting {
     updated_at: string;
 }
 /** Get a single setting by key. Returns undefined if not set. */
-declare function getSetting(db: Database, key: string): string | undefined;
+declare function getSetting(db: Database, key: string): Promise<string | undefined>;
 /** Get all settings as a key-value map. */
-declare function getAllSettings(db: Database): Record<string, string>;
+declare function getAllSettings(db: Database): Promise<Record<string, string>>;
 /** Get all settings with metadata. */
-declare function getAllSettingsDetailed(db: Database): UserSetting[];
+declare function getAllSettingsDetailed(db: Database): Promise<UserSetting[]>;
 /** Set a setting (insert or update). */
-declare function setSetting(db: Database, key: string, value: string): void;
+declare function setSetting(db: Database, key: string, value: string): Promise<void>;
 /** Delete a setting. Returns true if it existed. */
-declare function deleteSetting(db: Database, key: string): boolean;
+declare function deleteSetting(db: Database, key: string): Promise<boolean>;
 
 /**
  * Token repository — typed wrappers around the tokens table.
@@ -634,53 +820,57 @@ interface ScoredToken extends Token {
  * Create a new knowledge token.
  * Throws if a token with the same slug already exists.
  */
-declare function createToken(db: Database, input: CreateTokenInput): Token;
+declare function createToken(db: Database, input: CreateTokenInput): Promise<Token>;
 /**
  * Look up a token by its unique slug.
  * Returns undefined if not found.
  */
-declare function getTokenBySlug(db: Database, slug: string): Token | undefined;
+declare function getTokenBySlug(db: Database, slug: string): Promise<Token | undefined>;
 /**
  * Look up a token by its ULID.
  * Returns undefined if not found.
  */
-declare function getTokenById(db: Database, id: string): Token | undefined;
+declare function getTokenById(db: Database, id: string): Promise<Token | undefined>;
 /**
  * Update mutable fields on a token.
  *
  * Slug is intentionally immutable in v1 because it is referenced by other
  * parts of the system (for example agent skill metadata).
  */
-declare function updateToken(db: Database, slug: string, updates: UpdateTokenInput): Token;
+declare function updateToken(db: Database, slug: string, updates: UpdateTokenInput): Promise<Token>;
 /**
  * Mark a token as deprecated. Deprecated tokens are excluded from review queues
  * and search results but are not deleted — they can still be consulted.
  *
  * Throws if the token does not exist or is already deprecated.
  */
-declare function deprecateToken(db: Database, slug: string): Token;
+declare function deprecateToken(db: Database, slug: string): Promise<Token>;
 /**
  * Preview the rows that will be removed or updated when deleting a token.
  */
-declare function getTokenDeleteImpact(db: Database, slug: string): TokenDeleteImpact;
+declare function getTokenDeleteImpact(db: Database, slug: string): Promise<TokenDeleteImpact>;
 /**
  * Hard-delete a token and clean up non-FK references that point at its slug.
  */
-declare function deleteToken(db: Database, slug: string): DeleteTokenResult;
+declare function deleteToken(db: Database, slug: string): Promise<DeleteTokenResult>;
 /**
  * Fuzzy search for tokens by keyword query.
  *
- * Ported from the PoC's find-token command: splits the query into word
- * tokens, scores each database token by word overlap plus a substring
- * bonus on the concept field, and returns all matches sorted by score
- * descending.
+ * Uses SQLite LIKE queries on slug, concept, and domain to avoid loading
+ * every non-deprecated token into memory.  Each search term runs its own
+ * LIKE query; results are aggregated in JS with a word-overlap score plus
+ * a substring bonus on the concept field.  Results are returned sorted by
+ * relevance score descending.
+ *
+ * For very small search terms (< 3 chars) a light in-memory fallback is
+ * used to avoid matching every token.
  */
-declare function findTokens(db: Database, query: string): ScoredToken[];
+declare function findTokens(db: Database, query: string): Promise<ScoredToken[]>;
 /**
  * List all tokens, optionally filtered by domain.
  * Results are ordered by bloom_level then slug.
  */
-declare function listTokens(db: Database, options?: ListTokensOptions): Token[];
+declare function listTokens(db: Database, options?: ListTokensOptions): Promise<Token[]>;
 
 /**
  * Monitor log analyzer — maps observed shell commands to token ratings.
@@ -777,93 +967,6 @@ declare function getMonitorLogStats(sessionId: string): {
     lineCount: number;
 };
 
-/**
- * Shell hook code generation for zsh, bash, and PowerShell.
- *
- * Pure functions that return shell code strings. The CLI command
- * `zam monitor start/stop` calls these and prints to stdout.
- */
-/**
- * Generate zsh hooks that capture commands to a JSONL file.
- * Uses $EPOCHREALTIME for sub-second timestamp precision.
- */
-declare function generateZshHooks(monitorFile: string, sessionId: string): string;
-/**
- * Generate bash hooks that capture commands to a JSONL file.
- * Uses DEBUG trap for preexec, PROMPT_COMMAND for precmd.
- */
-declare function generateBashHooks(monitorFile: string, sessionId: string): string;
-/**
- * Generate PowerShell hooks that capture completed commands to a JSONL file.
- * PowerShell has no zsh-style preexec hook, so this records the most recent
- * history item from the prompt function after each command completes.
- */
-declare function generatePowerShellHooks(monitorFile: string, sessionId: string): string;
-/** Generate zsh code to remove monitor hooks. */
-declare function generateZshUnhooks(): string;
-/** Generate bash code to remove monitor hooks. */
-declare function generateBashUnhooks(): string;
-/** Generate PowerShell code to remove monitor hooks. */
-declare function generatePowerShellUnhooks(): string;
-
-/**
- * Skill Discovery — identifies recurring non-standard command patterns
- * across multiple sessions and proposes them as minimal reusable skills.
- *
- * The key insight from Increment 2: "The human's demonstrated competence
- * is the gate for automation — not the other way around." A pattern must
- * appear consistently across sessions before being proposed as a skill.
- *
- * Pure functions — no DB access. Callers provide command records and
- * existing skills; this module returns proposed skills.
- */
-
-interface CommandSequence {
-    /** The ordered command prefixes forming the pattern (e.g., ["git checkout", "npm install", "npm run build"]) */
-    steps: string[];
-    /** How many sessions contained this sequence */
-    sessionCount: number;
-    /** Total occurrences across all sessions */
-    totalOccurrences: number;
-    /** Example full commands from the most recent occurrence */
-    examples: string[];
-}
-interface SkillProposal {
-    /** Suggested slug for the skill */
-    slug: string;
-    /** Human-readable description of what the pattern does */
-    description: string;
-    /** The command steps forming the skill */
-    steps: string[];
-    /** How many sessions demonstrated this pattern */
-    sessionCount: number;
-    /** Confidence that this is a real, repeatable skill */
-    confidence: "high" | "medium" | "low";
-    /** Example commands from actual usage */
-    examples: string[];
-}
-interface DiscoveryOptions {
-    /** Minimum number of sessions a pattern must appear in (default: 2) */
-    minSessions?: number;
-    /** Minimum sequence length to consider (default: 2) */
-    minSequenceLength?: number;
-    /** Maximum sequence length to consider (default: 5) */
-    maxSequenceLength?: number;
-    /** Existing skill slugs to exclude from proposals */
-    existingSkillSlugs?: string[];
-}
-/**
- * Discover recurring command patterns across multiple sessions.
- *
- * Takes a map of session ID → command records, finds command sequences
- * that appear in multiple sessions, and proposes them as skills.
- *
- * @param sessionCommands - Map of session ID to that session's commands
- * @param options - Discovery configuration
- * @returns Array of skill proposals, sorted by confidence then session count
- */
-declare function discoverSkills(sessionCommands: Map<string, CommandRecord[]>, options?: DiscoveryOptions): SkillProposal[];
-
 /**
  * Cascade Block & Unblock — prerequisite-aware blocking logic.
  *
@@ -901,7 +1004,7 @@ interface UnblockResult {
  * @param tokenSlug - Slug of the token the user forgot
  * @returns Info about what was blocked and which prerequisites were surfaced
  */
-declare function cascadeBlock(db: Database, userId: string, tokenSlug: string): CascadeBlockResult;
+declare function cascadeBlock(db: Database, userId: string, tokenSlug: string): Promise<CascadeBlockResult>;
 /**
  * Scan all blocked cards for a user and unblock any whose prerequisites are met.
  *
@@ -916,7 +1019,7 @@ declare function cascadeBlock(db: Database, userId: string, tokenSlug: string):
  * @param userId - The user whose blocked cards to check
  * @returns List of cards that were unblocked
  */
-declare function unblockReady(db: Database, userId: string): UnblockResult;
+declare function unblockReady(db: Database, userId: string): Promise<UnblockResult>;
 
 /**
  * FSRS-5 — Free Spaced Repetition Scheduler (v5)
@@ -970,6 +1073,168 @@ interface FSRS {
  */
 declare function createFSRS(params?: Partial<FSRSParameters>): FSRS;
 
+/**
+ * Session synthesis connects shell observation to durable learning state.
+ *
+ * A preview analyzes monitor commands without mutating the database. Applying
+ * one confirmed candidate updates the card, review log, session step, blocking
+ * state, and synthesis audit record in a single transaction.
+ */
+
+type SynthesisConfidence = "medium" | "high";
+interface SessionSynthesisCandidate {
+    tokenId: string;
+    tokenSlug: string;
+    concept: string;
+    domain: string;
+    inferredRating: Rating;
+    confidence: SynthesisConfidence;
+    evidence: ObservationRating["evidence"];
+    matchedCommandTexts: string[];
+}
+interface PrepareSessionSynthesisInput {
+    sessionId: string;
+    explicitPatterns?: TokenPattern[];
+    minConfidence?: SynthesisConfidence;
+    /** Test and integration hook; normal callers read the monitor log. */
+    commands?: CommandRecord[];
+}
+interface SessionSynthesisPreview {
+    sessionId: string;
+    userId: string;
+    patternCount: number;
+    commandCount: number;
+    alreadyApplied: number;
+    skippedLowConfidence: number;
+    candidates: SessionSynthesisCandidate[];
+    unmatchedCommands: string[];
+    timeSpan: {
+        start: string;
+        end: string;
+        durationMs: number;
+    } | null;
+}
+interface SessionSynthesisEvidence {
+    signals: ObservationRating["evidence"];
+    matchedCommandTexts: string[];
+}
+interface SessionSynthesisRecord {
+    session_id: string;
+    token_id: string;
+    card_id: string;
+    inferred_rating: Rating;
+    confirmed_rating: Rating;
+    confidence: SynthesisConfidence;
+    evidence: SessionSynthesisEvidence;
+    review_log_id: string;
+    session_step_id: string;
+    created_at: string;
+}
+interface ApplySessionSynthesisInput {
+    sessionId: string;
+    tokenSlug: string;
+    inferredRating: Rating;
+    confirmedRating: Rating;
+    confidence: SynthesisConfidence;
+    evidence: ObservationRating["evidence"];
+    matchedCommandTexts: string[];
+}
+interface ApplySessionSynthesisResult {
+    applied: boolean;
+    record: SessionSynthesisRecord;
+    blocked?: Awaited<ReturnType<typeof cascadeBlock>>;
+}
+declare function getSessionSynthesisRecords(db: Database, sessionId: string): Promise<SessionSynthesisRecord[]>;
+declare function prepareSessionSynthesis(db: Database, input: PrepareSessionSynthesisInput): Promise<SessionSynthesisPreview>;
+declare function applySessionSynthesis(db: Database, input: ApplySessionSynthesisInput): Promise<ApplySessionSynthesisResult>;
+
+/**
+ * Shell hook code generation for zsh, bash, and PowerShell.
+ *
+ * Pure functions that return shell code strings. The CLI command
+ * `zam monitor start/stop` calls these and prints to stdout.
+ */
+/**
+ * Generate zsh hooks that capture commands to a JSONL file.
+ * Uses $EPOCHREALTIME for sub-second timestamp precision.
+ */
+declare function generateZshHooks(monitorFile: string, sessionId: string): string;
+/**
+ * Generate bash hooks that capture commands to a JSONL file.
+ * Uses DEBUG trap for preexec, PROMPT_COMMAND for precmd.
+ */
+declare function generateBashHooks(monitorFile: string, sessionId: string): string;
+/**
+ * Generate PowerShell hooks that capture completed commands to a JSONL file.
+ * PowerShell has no zsh-style preexec hook, so this records the most recent
+ * history item from the prompt function after each command completes.
+ */
+declare function generatePowerShellHooks(monitorFile: string, sessionId: string): string;
+/** Generate zsh code to remove monitor hooks. */
+declare function generateZshUnhooks(): string;
+/** Generate bash code to remove monitor hooks. */
+declare function generateBashUnhooks(): string;
+/** Generate PowerShell code to remove monitor hooks. */
+declare function generatePowerShellUnhooks(): string;
+
+/**
+ * Skill Discovery — identifies recurring non-standard command patterns
+ * across multiple sessions and proposes them as minimal reusable skills.
+ *
+ * The key insight from Increment 2: "The human's demonstrated competence
+ * is the gate for automation — not the other way around." A pattern must
+ * appear consistently across sessions before being proposed as a skill.
+ *
+ * Pure functions — no DB access. Callers provide command records and
+ * existing skills; this module returns proposed skills.
+ */
+
+interface CommandSequence {
+    /** The ordered command prefixes forming the pattern (e.g., ["git checkout", "npm install", "npm run build"]) */
+    steps: string[];
+    /** How many sessions contained this sequence */
+    sessionCount: number;
+    /** Total occurrences across all sessions */
+    totalOccurrences: number;
+    /** Example full commands from the most recent occurrence */
+    examples: string[];
+}
+interface SkillProposal {
+    /** Suggested slug for the skill */
+    slug: string;
+    /** Human-readable description of what the pattern does */
+    description: string;
+    /** The command steps forming the skill */
+    steps: string[];
+    /** How many sessions demonstrated this pattern */
+    sessionCount: number;
+    /** Confidence that this is a real, repeatable skill */
+    confidence: "high" | "medium" | "low";
+    /** Example commands from actual usage */
+    examples: string[];
+}
+interface DiscoveryOptions {
+    /** Minimum number of sessions a pattern must appear in (default: 2) */
+    minSessions?: number;
+    /** Minimum sequence length to consider (default: 2) */
+    minSequenceLength?: number;
+    /** Maximum sequence length to consider (default: 5) */
+    maxSequenceLength?: number;
+    /** Existing skill slugs to exclude from proposals */
+    existingSkillSlugs?: string[];
+}
+/**
+ * Discover recurring command patterns across multiple sessions.
+ *
+ * Takes a map of session ID → command records, finds command sequences
+ * that appear in multiple sessions, and proposes them as skills.
+ *
+ * @param sessionCommands - Map of session ID to that session's commands
+ * @param options - Discovery configuration
+ * @returns Array of skill proposals, sorted by confidence then session count
+ */
+declare function discoverSkills(sessionCommands: Map<string, CommandRecord[]>, options?: DiscoveryOptions): SkillProposal[];
+
 /**
  * Rating Evaluator
  *
@@ -984,6 +1249,7 @@ interface EvaluateInput {
     rating: Rating;
     sessionId?: string;
     responseTimeMs?: number;
+    reviewLogId?: string;
 }
 interface EvaluateResult {
     nextDueAt: string;
@@ -1001,7 +1267,7 @@ interface EvaluateResult {
  * Note: blocking logic (cascade-block) is handled separately by the caller
  * when rating === 1 and the token has prerequisites.
  */
-declare function evaluateRating(db: Database, input: EvaluateInput): EvaluateResult;
+declare function evaluateRating(db: Database, input: EvaluateInput): Promise<EvaluateResult>;
 
 type ReviewActionType = "rate" | "skip" | "edit-token" | "deprecate-token" | "delete-token" | "delete-card" | "stop";
 interface ExecuteReviewActionInput {
@@ -1022,7 +1288,7 @@ interface ReviewActionResult {
     skipped?: boolean;
     stopped?: boolean;
 }
-declare function executeReviewAction(db: Database, input: ExecuteReviewActionInput): ReviewActionResult;
+declare function executeReviewAction(db: Database, input: ExecuteReviewActionInput): Promise<ReviewActionResult>;
 
 /**
  * Active Recall Prompt Generation
@@ -1174,7 +1440,7 @@ interface ReviewQueue {
  * @param options - Queue building options
  * @returns The assembled review queue with metadata
  */
-declare function buildReviewQueue(db: Database, options: ReviewQueueOptions): ReviewQueue;
+declare function buildReviewQueue(db: Database, options: ReviewQueueOptions): Promise<ReviewQueue>;
 
 /**
  * Get the path to ZAM's internal package SKILL.md.
@@ -1190,10 +1456,9 @@ declare function distributeGlobalSkills(home?: string): Array<{
     success: boolean;
 }>;
 /**
- * Inject the ZAM shell observation hook into user profile scripts so monitoring
- * is automatically initialized on startup.
+ * Add opt-in helpers for starting a monitored session to user shell profiles.
  */
-declare function injectShellHooks(): Array<{
+declare function injectShellHooks(home?: string): Array<{
     shell: string;
     file: string;
     success: boolean;
@@ -1216,10 +1481,105 @@ type TranslationKey = "welcome" | "new_review_relearn" | "domains" | "instructio
  */
 declare function t(locale: SupportedLocale, key: TranslationKey, params?: Record<string, string | number>): string;
 
+/**
+ * Update-decision logic — Increment 12, Phase 5.
+ *
+ * The brain behind "the app noticed a newer version": given the current and
+ * latest versions and how this copy was installed, decide what the UI should
+ * do. Deliberately network-free and pure, so it is fully unit-tested; the
+ * actual version fetch (e.g. GitHub releases) and the Tauri self-update live in
+ * the CLI/desktop layers that call this.
+ */
+type InstallChannel = "developer" | "direct" | "winget" | "homebrew";
+/** Provisional package identifiers; finalized when channels ship (Phase 2). */
+declare const WINGET_PACKAGE_ID = "ZAM.ZAM";
+declare const HOMEBREW_CASK = "zam";
+type UpdateActionKind = "none" | "self-update" | "run-command" | "inform";
+interface UpdateDecision {
+    updateAvailable: boolean;
+    currentVersion: string;
+    latestVersion: string;
+    channel: InstallChannel;
+    /** What the UI should do about the update. */
+    action: UpdateActionKind;
+    /** For "run-command"/"inform": the command to surface to the user. */
+    command?: string;
+    /** Locale-agnostic explanation; the UI provides its own localized copy. */
+    reason: string;
+}
+/**
+ * Compare two semver-ish versions. Returns 1 if `a` is newer than `b`, -1 if
+ * older, 0 if equal. A version with a prerelease tag (1.0.0-beta) sorts below
+ * the same core release (1.0.0), per semver.
+ */
+declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+/**
+ * Decide what to do given current/latest versions and the install channel.
+ * The mechanism follows how the copy was installed so we never self-replace a
+ * package-managed install or a source checkout.
+ */
+declare function decideUpdate(input: {
+    currentVersion: string;
+    latestVersion: string;
+    channel: InstallChannel;
+}): UpdateDecision;
+
+/**
+ * Per-machine install configuration — Increment 12, Phase 3.
+ *
+ * Records whether this machine runs ZAM in "developer" mode (source checkout,
+ * git-backed workspace, manual `git`/`npm` updates) or "default" mode (an
+ * installed application updated through a package manager or the in-app
+ * updater). Stored in ~/.zam/config.json — a per-machine file, NOT the database
+ * and NOT the personal folder, so the mode never travels through a shared Turso
+ * database or a synced folder, where it would be wrong for the other machine.
+ *
+ * The personal-content folder itself is unchanged: it stays the existing
+ * `personal.workspace_dir` setting, and can already point at any local or
+ * file-synced directory (Drive, OneDrive, Dropbox, iCloud) — no GitHub required.
+ */
+
+type InstallMode = "developer" | "default";
+interface InstallConfig {
+    mode?: InstallMode;
+    /** How this copy was installed; drives the self-update mechanism. */
+    channel?: InstallChannel;
+}
+/** Load ~/.zam/config.json. Returns an empty config if missing or unreadable. */
+declare function loadInstallConfig(path?: string): InstallConfig;
+/** Persist the install config, preserving any unrelated keys already on disk. */
+declare function saveInstallConfig(config: InstallConfig, path?: string): void;
+/**
+ * This machine's install mode. Defaults to "developer" — the only historical
+ * mode — so existing source/CLI installs keep their behavior. A packaged
+ * "default" install writes mode explicitly at install time.
+ */
+declare function getInstallMode(path?: string): InstallMode;
+declare function setInstallMode(mode: InstallMode, path?: string): void;
+/**
+ * How this copy was installed, used to pick the self-update mechanism. Falls
+ * back to "developer" for developer mode and "direct" for an installed app
+ * whose channel was not recorded.
+ */
+declare function getInstallChannel(path?: string): InstallChannel;
+declare function setInstallChannel(channel: InstallChannel, path?: string): void;
+/**
+ * Best-effort detection of the file-sync provider a folder lives in, from its
+ * path. Used only for friendly messaging ("this folder syncs via OneDrive —
+ * good for moving snapshots between machines"), never for behavior.
+ */
+declare function detectSyncProvider(dir: string): string | null;
+
 interface InstallResult {
     success: boolean;
     message: string;
 }
+type LocalLLMRunner = "fastflowlm" | "ollama" | "generic";
+/** A resolved way to install a tool: a human label and the command to run. */
+interface InstallPlan {
+    method: string;
+    command: string;
+}
 /**
  * Check if a command is executable on the system.
  */
@@ -1232,6 +1592,32 @@ declare function installFastFlowLM(): InstallResult;
  * Install Ollama via Homebrew on macOS.
  */
 declare function installOllama(): InstallResult;
+/**
+ * Prepare the recommended model after installing a local LLM runner.
+ */
+declare function prepareLocalModel(runner: LocalLLMRunner, model: string): InstallResult;
+/**
+ * Pick how to install the opencode agent for the current machine.
+ *
+ * npm is preferred on every platform: ZAM already requires Node, and the
+ * `opencode-ai` package pulls the correct native binary for Apple Silicon and
+ * Windows on ARM — avoiding the bash-on-Windows and Homebrew-tap caveats.
+ * Returns null when no automatic method is available (e.g. Windows without npm,
+ * Scoop, or Chocolatey).
+ */
+declare function planOpenCodeInstall(env: {
+    platform: NodeJS.Platform;
+    hasNpm: boolean;
+    hasBrew: boolean;
+    hasScoop: boolean;
+    hasChoco: boolean;
+}): InstallPlan | null;
+/**
+ * Install the opencode agent (the default agent ZAM provisions). opencode reads
+ * the AGENTS.md that `zam setup` writes, so it picks up the ZAM skill once both
+ * are present.
+ */
+declare function installOpenCode(): InstallResult;
 
 interface SystemProfile {
     os: "windows" | "macos" | "linux" | "unknown";
@@ -1255,20 +1641,20 @@ interface RepoPaths {
  * Resolve absolute paths for personal, team, and organization repositories.
  * Personal falls back to personal.workspace_dir if repo.personal is not set.
  */
-declare function getRepoPaths(db: Database): RepoPaths;
+declare function getRepoPaths(db: Database): Promise<RepoPaths>;
 /**
  * Resolve a specific repo's path, or null if not configured.
  */
-declare function resolveRepoPath(db: Database, type: "personal" | "team" | "org"): string | null;
+declare function resolveRepoPath(db: Database, type: "personal" | "team" | "org"): Promise<string | null>;
 /**
  * Resolve paths to all existing "/beliefs" directories in the hierarchy,
  * sorted from most specific (personal) to most general (org).
  */
-declare function resolveAllBeliefPaths(db: Database): string[];
+declare function resolveAllBeliefPaths(db: Database): Promise<string[]>;
 /**
  * Resolve paths to all existing "/goals" directories in the hierarchy,
  * sorted from most specific (personal) to most general (org).
  */
-declare function resolveAllGoalPaths(db: Database): string[];
+declare function resolveAllGoalPaths(db: Database): Promise<string[]>;
 
-export { type ADOConfig, type ADOCredentials, type AgentSkill, type AnalysisResult, type BloomLevel$1 as BloomLevel, type Card, type CardDeletionImpact, type CardState$1 as CardState, type CascadeBlockResult, type CommandRecord, type CommandSequence, type CreateAgentSkillInput, type CreateGoalInput, type CreateReviewInput, type CreateSessionInput, type CreateTokenInput, type Credentials, DEFAULT_REVIEW_CONTEXT_MAX_CHARS, type DeleteCardResult, type DeleteTokenResult, type DiscoveryOptions, type DomainCompetence, type EvaluateInput, type EvaluateResult, type ExecuteReviewActionInput, type ExecutionContext, type FSRSParameters, type Goal, type GoalFrontmatter, type GoalStatus, type GoalSummary, type InstallResult, type LogStepInput, type MonitorEvent, type ObservationRating, type Prerequisite, type PrerequisiteWithToken, type PromptInput, type Rating, type RecallPrompt, type RepoPaths, type ResolvedReference, type ReviewActionResult, type ReviewActionType, type ReviewContext, type ReviewLog, type ReviewQueue, type ReviewQueueItem, type ReviewQueueOptions, type SchedulingCard, type Session, type SessionStep, type SessionSummary, type SkillProposal, type SkillSource, type SupportedLocale, type SymbiosisMode, type SystemProfile, type Token, type TokenDeleteImpact, type TokenPattern, type TranslationKey, type TursoCredentials, type UnblockResult, type UpdateCardInput, type UpdateTokenInput, type UserSetting, type UserStats, type WorkItem, addPrerequisite, analyzeObservation, buildReviewQueue, cascadeBlock, clearADOCredentials, clearTursoCredentials, createAgentSkill, createFSRS, createGoal, createToken, deleteCardForUser, deleteSetting, deleteToken, deprecateToken, detectSystemLocale, discoverSkills, distributeGlobalSkills, endSession, ensureCard, ensureMonitorDir, evaluateRating, executeReviewAction, extractTasks, extractTokenRefs, fetchActiveWorkItems, findTokens, generateBashHooks, generateBashUnhooks, generateConceptFreeCue, generatePowerShellHooks, generatePowerShellUnhooks, generatePrompt, generateZshHooks, generateZshUnhooks, getADOCredentials, getAgentSkill, getAllSettings, getAllSettingsDetailed, getBlockedCards, getCard, getCardById, getCardDeletionImpact, getDefaultDbPath, getDependents, getDomainCompetence, getDueCards, getGoal, getGoalTree, getMonitorDir, getMonitorLogStats, getMonitorPath, getPackageSkillPath, getPrerequisites, getRepoPaths, getReviewsForCard, getReviewsForUser, getSessionSummary, getSetting, getSystemProfile, getTokenById, getTokenBySlug, getTokenDeleteImpact, getTursoCredentials, getUserStats, hasCommand, injectShellHooks, installFastFlowLM, installOllama, interleave, listAgentSkills, listGoals, listTokens, loadADOConfig, loadCredentials, logReview, logStep, matchesFilePath, monitorLogExists, normalizeLocale, normalizePath, openDatabase, openDatabaseWithSync, pairCommands, parseGoalFile, parseMonitorLog, readMonitorLog, resolveAllBeliefPaths, resolveAllGoalPaths, resolveReference, resolveRepoPath, resolveReviewContext, saveCredentials, serializeGoal, setADOCredentials, setSetting, setTursoCredentials, startSession, t, unblockReady, updateCard, updateGoalStatus, updateToken, writeMonitorEvent };
+export { type ADOConfig, type ADOCredentials, type AgentSkill, type AnalysisResult, type ApplySessionSynthesisInput, type ApplySessionSynthesisResult, type BloomLevel$1 as BloomLevel, type Card, type CardDeletionImpact, type CardState$1 as CardState, type CascadeBlockResult, type CommandRecord, type CommandSequence, type ConnectionOptions, type CreateAgentSkillInput, type CreateGoalInput, type CreateReviewInput, type CreateSessionInput, type CreateTokenInput, type Credentials, DEFAULT_REVIEW_CONTEXT_MAX_CHARS, type Database, type DatabaseProvider, type DatabaseValue, type DeleteCardResult, type DeleteTokenResult, type DiscoveryOptions, type DomainCompetence, type EvaluateInput, type EvaluateResult, type ExecuteReviewActionInput, type ExecutionContext, type FSRSParameters, type Goal, type GoalFrontmatter, type GoalStatus, type GoalSummary, HOMEBREW_CASK, type ImportResult, type InstallChannel, type InstallConfig, type InstallMode, type InstallPlan, type InstallResult, type LocalLLMRunner, type LogStepInput, type MonitorEvent, type Neighborhood, type NeighborhoodToken, type ObservationRating, type PrepareSessionSynthesisInput, type Prerequisite, type PrerequisiteWithToken, type PromptInput, type Rating, type RecallPrompt, type RemoteDatabaseOptions, type RepoPaths, type ResolvedReference, type ReviewActionResult, type ReviewActionType, type ReviewContext, type ReviewLog, type ReviewQueue, type ReviewQueueItem, type ReviewQueueOptions, type RunResult, SNAPSHOT_VERSION, type SchedulingCard, type Session, type SessionStep, type SessionSummary, type SessionSynthesisCandidate, type SessionSynthesisEvidence, type SessionSynthesisPreview, type SessionSynthesisRecord, type SkillProposal, type SkillSource, type SnapshotManifest, type Statement, type SupportedLocale, type SymbiosisMode, type SynthesisConfidence, type SystemProfile, type Token, type TokenDeleteImpact, type TokenPattern, type TranslationKey, type TursoCredentials, type UnblockResult, type UpdateActionKind, type UpdateCardInput, type UpdateDecision, type UpdateTokenInput, type UserSetting, type UserStats, WINGET_PACKAGE_ID, type WorkItem, addPrerequisite, analyzeObservation, applySessionSynthesis, buildReviewQueue, cascadeBlock, clearADOCredentials, clearTursoCredentials, compareVersions, createAgentSkill, createFSRS, createGoal, createToken, decideUpdate, deleteCardForUser, deleteSetting, deleteToken, deprecateToken, detectSyncProvider, detectSystemLocale, discoverSkills, distributeGlobalSkills, endSession, ensureCard, ensureMonitorDir, evaluateRating, executeReviewAction, exportSnapshot, extractTasks, extractTokenRefs, fetchActiveWorkItems, findTokens, generateBashHooks, generateBashUnhooks, generateConceptFreeCue, generatePowerShellHooks, generatePowerShellUnhooks, generatePrompt, generateZshHooks, generateZshUnhooks, getADOCredentials, getAgentSkill, getAllSettings, getAllSettingsDetailed, getBlockedCards, getCard, getCardById, getCardDeletionImpact, getDefaultDbPath, getDependents, getDomainCompetence, getDueCards, getGoal, getGoalTree, getInstallChannel, getInstallMode, getMonitorDir, getMonitorLogStats, getMonitorPath, getPackageSkillPath, getPrerequisites, getRepoPaths, getReviewsForCard, getReviewsForUser, getSessionSummary, getSessionSynthesisRecords, getSetting, getSystemProfile, getTokenById, getTokenBySlug, getTokenDeleteImpact, getTokenNeighborhood, getTursoCredentials, getUserStats, hasCommand, importSnapshot, injectShellHooks, installFastFlowLM, installOllama, installOpenCode, interleave, listAgentSkills, listGoals, listTokens, loadADOConfig, loadCredentials, loadInstallConfig, logReview, logStep, matchesFilePath, monitorLogExists, normalizeLocale, normalizePath, openDatabase, openDatabaseWithSync, openRemoteDatabase, pairCommands, parseGoalFile, parseMonitorLog, parseSnapshot, planOpenCodeInstall, prepareLocalModel, prepareSessionSynthesis, readMonitorLog, resolveAllBeliefPaths, resolveAllGoalPaths, resolveReference, resolveRepoPath, resolveReviewContext, saveCredentials, saveInstallConfig, serializeGoal, setADOCredentials, setInstallChannel, setInstallMode, setSetting, setTursoCredentials, startSession, t, unblockReady, updateCard, updateGoalStatus, updateToken, verifySnapshot, wouldCreateCycle, writeMonitorEvent };