gnosys 5.11.4 → 5.12.2

package/dist/lib/restoreCommand.d.ts

@@ -0,0 +1,5 @@
+export type RestoreCommandOptions = {
+    from?: string;
+    json?: boolean;
+};
+export declare function runRestoreCommand(backupFile: string, opts: RestoreCommandOptions): Promise<void>;

package/dist/lib/restoreCommand.js

@@ -0,0 +1,35 @@
+import path from "path";
+import { GnosysDB } from "./db.js";
+export async function runRestoreCommand(backupFile, opts) {
+    const resolved = path.resolve(opts.from || backupFile);
+    let db = null;
+    try {
+        db = GnosysDB.restore(resolved);
+        const counts = db.getMemoryCount();
+        const projectCount = db.getAllProjects().length;
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true, source: resolved, memories: counts.total,
+                active: counts.active, archived: counts.archived, projects: projectCount,
+            }));
+        }
+        else {
+            console.log(`Database restored from ${resolved}`);
+            console.log(`  Memories: ${counts.total} (${counts.active} active, ${counts.archived} archived)`);
+            console.log(`  Projects: ${projectCount}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Restore failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        db?.close();
+    }
+}

package/dist/lib/rulesGen.d.ts

@@ -47,6 +47,14 @@ export declare function syncRules(centralDb: GnosysDB, projectDir: string, agent
  * If target is "global", syncs to ~/.claude/CLAUDE.md.
  */
 export declare function syncToTarget(centralDb: GnosysDB, projectDir: string, target: string, projectId: string | null): Promise<RulesGenResult[]>;
+/**
+ * Remove the GNOSYS block from every known agent rules file in a project —
+ * the uninstall counterpart of syncToTarget (v5.12.1: wired into
+ * `gnosys cleanup --rules`). Checks every known target rather than only
+ * detected ones, so leftovers survive even if the agent dir was removed.
+ * Returns the relative paths actually cleaned.
+ */
+export declare function removeRulesFromProject(projectDir: string): Promise<string[]>;
 /**
  * Remove the GNOSYS block from a rules file (cleanup).
  */

package/dist/lib/rulesGen.js

@@ -254,6 +254,22 @@ export async function syncToTarget(centralDb, projectDir, target, projectId) {
     }
     return results;
 }
+/**
+ * Remove the GNOSYS block from every known agent rules file in a project —
+ * the uninstall counterpart of syncToTarget (v5.12.1: wired into
+ * `gnosys cleanup --rules`). Checks every known target rather than only
+ * detected ones, so leftovers survive even if the agent dir was removed.
+ * Returns the relative paths actually cleaned.
+ */
+export async function removeRulesFromProject(projectDir) {
+    const cleaned = [];
+    for (const relPath of Object.values(TARGET_PATHS)) {
+        const filePath = path.join(projectDir, relPath);
+        if (await removeRulesBlock(filePath))
+            cleaned.push(relPath);
+    }
+    return cleaned;
+}
 /**
  * Remove the GNOSYS block from a rules file (cleanup).
  */

package/dist/lib/sandboxStartCommand.d.ts

@@ -0,0 +1,6 @@
+export type SandboxStartCommandOptions = {
+    persistent?: boolean;
+    dbPath?: string;
+    json?: boolean;
+};
+export declare function runSandboxStartCommand(opts: SandboxStartCommandOptions): Promise<void>;

package/dist/lib/sandboxStartCommand.js

@@ -0,0 +1,25 @@
+export async function runSandboxStartCommand(opts) {
+    try {
+        const { startSandbox } = await import("../sandbox/manager.js");
+        const pid = await startSandbox({
+            persistent: opts.persistent,
+            dbPath: opts.dbPath,
+            wait: true,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, pid }));
+        }
+        else {
+            console.log(`Gnosys sandbox running (pid: ${pid})`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Failed to start sandbox: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/sandboxStatusCommand.d.ts

@@ -0,0 +1,4 @@
+export type SandboxStatusCommandOptions = {
+    json?: boolean;
+};
+export declare function runSandboxStatusCommand(opts: SandboxStatusCommandOptions): Promise<void>;

package/dist/lib/sandboxStatusCommand.js

@@ -0,0 +1,24 @@
+export async function runSandboxStatusCommand(opts) {
+    try {
+        const { sandboxStatus } = await import("../sandbox/manager.js");
+        const status = await sandboxStatus();
+        if (opts.json) {
+            console.log(JSON.stringify(status, null, 2));
+        }
+        else if (status.running) {
+            console.log(`Sandbox running (pid: ${status.pid}, socket: ${status.socketPath})`);
+        }
+        else {
+            console.log("Sandbox is not running. Start with: gnosys sandbox start");
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/sandboxStopCommand.d.ts

@@ -0,0 +1,4 @@
+export type SandboxStopCommandOptions = {
+    json?: boolean;
+};
+export declare function runSandboxStopCommand(opts: SandboxStopCommandOptions): Promise<void>;

package/dist/lib/sandboxStopCommand.js

@@ -0,0 +1,21 @@
+export async function runSandboxStopCommand(opts) {
+    try {
+        const { stopSandbox } = await import("../sandbox/manager.js");
+        const wasRunning = await stopSandbox();
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, wasRunning }));
+        }
+        else {
+            console.log(wasRunning ? "Sandbox stopped." : "Sandbox was not running.");
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Failed to stop sandbox: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/search.d.ts

@@ -17,8 +17,6 @@ export interface DiscoverResult {
 }
 export declare class GnosysSearch {
     private db;
-    private storePath;
-    private available;
     constructor(storePath: string);
     private initSchema;
     /**

package/dist/lib/search.js

@@ -3,7 +3,6 @@
  * FTS5-based search and discovery across all Gnosys stores.
  */
 // Dynamic import — gracefully handles missing native module (dlopen failures)
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let Database = null;
 try {
     Database = (await import("better-sqlite3")).default;
@@ -13,12 +12,8 @@ catch {
 }
 import path from "path";
 export class GnosysSearch {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     db = null;
-    storePath;
-    available = false;
     constructor(storePath) {
-        this.storePath = storePath;
         if (!Database) {
             // Native module not available — search features disabled
             return;
@@ -34,7 +29,6 @@ export class GnosysSearch {
             this.initSchema();
             // Smoke-test: insert + delete to confirm journal ops work
             this.db.exec("CREATE TABLE IF NOT EXISTS _write_test (v INTEGER); INSERT INTO _write_test VALUES (1); DELETE FROM _write_test; DROP TABLE _write_test;");
-            this.available = true;
         }
         catch {
             // Fallback to in-memory (works everywhere, rebuilt on each start)
@@ -44,7 +38,6 @@ export class GnosysSearch {
             catch { /* ignore */ }
             this.db = new Database(":memory:");
             this.initSchema();
-            this.available = true;
         }
     }
     initSchema() {

package/dist/lib/searchCommand.d.ts

@@ -0,0 +1,9 @@
+export type SearchCommandOptions = {
+    limit: string;
+    json?: boolean;
+    federated?: boolean;
+    scope?: string;
+    directory?: string;
+    idFormat?: string;
+};
+export declare function runSearchCommand(query: string, opts: SearchCommandOptions): Promise<void>;

package/dist/lib/searchCommand.js

@@ -0,0 +1,90 @@
+import { logError } from "./log.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runSearchCommand(query, opts) {
+    // Federated search path — uses central DB with tier boosting
+    if (opts.federated || opts.scope) {
+        const { resolveClientRead } = await import("./clientReadResolve.js");
+        const resolved = resolveClientRead();
+        if (!resolved) {
+            console.error("Central DB not available. Run 'gnosys migrate --to-central' first.");
+            process.exit(1);
+        }
+        try {
+            const { federatedSearch, detectCurrentProject } = await import("./federated.js");
+            const projectId = await detectCurrentProject(resolved.db, opts.directory || undefined);
+            const scopeFilter = opts.scope ? opts.scope.split(",").map(s => s.trim()) : undefined;
+            const results = federatedSearch(resolved.db, query, {
+                limit: parseInt(opts.limit, 10),
+                projectId,
+                scopeFilter,
+            });
+            outputResult(!!opts.json, { query, projectId, count: results.length, results }, () => {
+                if (results.length === 0) {
+                    console.log(`No results for "${query}".`);
+                    return;
+                }
+                const ctx = projectId ? `Context: project ${projectId}` : "No project detected";
+                console.log(ctx);
+                for (const [i, r] of results.entries()) {
+                    const proj = r.projectName ? ` [${r.projectName}]` : "";
+                    console.log(`\n${i + 1}. ${r.title} (${r.category})${proj}`);
+                    console.log(`   scope: ${r.scope} | score: ${r.score.toFixed(4)} | boosts: ${r.boosts.join(", ")}`);
+                    if (r.snippet)
+                        console.log(`   ${r.snippet.substring(0, 120)}`);
+                }
+            });
+        }
+        catch (err) {
+            logError(err, { module: "cli", op: "search" });
+            process.exit(1);
+        }
+        finally {
+            resolved.release();
+        }
+        return;
+    }
+    // DB-based search path — uses central DB FTS5 (+ v13 client overlay)
+    const { resolveClientRead, searchWithOverlay } = await import("./clientReadResolve.js");
+    const resolved = resolveClientRead();
+    if (!resolved) {
+        console.error("Central DB not available. Run 'gnosys init' first.");
+        process.exit(1);
+    }
+    try {
+        const results = searchWithOverlay(resolved, query, parseInt(opts.limit, 10));
+        if (results.length === 0) {
+            outputResult(!!opts.json, { query, results: [] }, () => {
+                console.log(`No results for "${query}".`);
+            });
+            return;
+        }
+        const { formatMemoryIdHyperlink: formatMemoryId, buildProjectNameLookup, parseIdFormat } = await import("./idFormat.js");
+        const idFormat = parseIdFormat(opts.idFormat);
+        const projectNames = buildProjectNameLookup(resolved.localDb);
+        outputResult(!!opts.json, { query, count: results.length, results }, () => {
+            console.log(`Found ${results.length} results for "${query}":\n`);
+            for (const r of results) {
+                const projectName = r.project_id ? projectNames.get(r.project_id) || null : null;
+                const displayId = formatMemoryId(r.id, projectName, idFormat);
+                console.log(`  ${r.title}`);
+                console.log(`    id: ${displayId}`);
+                console.log(`    ${r.snippet.replace(/>>>/g, "").replace(/<<</g, "")}`);
+                console.log();
+            }
+        });
+    }
+    catch (err) {
+        logError(err, { module: "cli", op: "search" });
+        process.exit(1);
+    }
+    finally {
+        resolved.release();
+    }
+}

package/dist/lib/semanticSearchCommand.d.ts

@@ -0,0 +1,8 @@
+import type { GnosysResolver } from "./resolver.js";
+export type SemanticSearchCommandOptions = {
+    limit: string;
+    json?: boolean;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runSemanticSearchCommand(getResolver: GetResolver, query: string, opts: SemanticSearchCommandOptions): Promise<void>;
+export {};

package/dist/lib/semanticSearchCommand.js

@@ -0,0 +1,52 @@
+import { GnosysSearch } from "./search.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runSemanticSearchCommand(getResolver, query, opts) {
+    const resolver = await getResolver();
+    const stores = resolver.getStores();
+    if (stores.length === 0) {
+        console.error("No stores found.");
+        process.exit(1);
+    }
+    const storePath = stores[0].path;
+    const search = new GnosysSearch(storePath);
+    search.clearIndex();
+    for (const s of stores) {
+        await search.addStoreMemories(s.store, s.label);
+    }
+    const { GnosysEmbeddings } = await import("./embeddings.js");
+    const { GnosysHybridSearch } = await import("./hybridSearch.js");
+    const embeddings = new GnosysEmbeddings(storePath);
+    const hybridSearch = new GnosysHybridSearch(search, embeddings, resolver, storePath);
+    const results = await hybridSearch.hybridSearch(query, parseInt(opts.limit, 10), "semantic");
+    outputResult(!!opts.json, {
+        query,
+        count: results.length,
+        results: results.map((r) => ({
+            title: r.title,
+            relativePath: r.relativePath,
+            score: r.score,
+            snippet: r.snippet,
+        })),
+    }, () => {
+        if (results.length === 0) {
+            console.log(`No semantic results for "${query}". Run gnosys reindex first.`);
+            return;
+        }
+        console.log(`Found ${results.length} semantic results for "${query}":\n`);
+        for (const r of results) {
+            console.log(`  ${r.title}`);
+            console.log(`    Path: ${r.relativePath}`);
+            console.log(`    Similarity: ${r.score.toFixed(4)}`);
+            console.log(`    ${r.snippet.substring(0, 120)}...\n`);
+        }
+    });
+    search.close();
+    embeddings.close();
+}

package/dist/lib/setup/configSetRender.js

@@ -29,6 +29,8 @@ export const KNOWN_CONFIG_KEYS = [
     "lmstudio-model",
     "xai-model",
     "mistral-model",
+    "openrouter-model",
+    "openrouter-key",
     "custom-url",
     "custom-model",
     "custom-key",

package/dist/lib/setup/providerGlyphs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Terminal brand marks for LLM providers (single-width glyphs + color).
+ */
+import type { LLMProviderName } from "../config.js";
+export interface ProviderMark {
+    glyph: string;
+    /** ANSI foreground for the glyph */
+    ansi: string;
+    shortName: string;
+}
+export declare function getProviderMark(provider: string): ProviderMark;
+/** Colored single-character (or short) logo for lists and tables. */
+export declare function renderProviderMark(provider: string): string;
+/** `◆ Anthropic` with brand-colored glyph. */
+export declare function renderProviderLabel(provider: string): string;
+/** Cloud providers that use API keys in the providers screen. */
+export declare const CLOUD_PROVIDERS_FOR_KEYS: LLMProviderName[];
+/** Local providers shown in the list (no key management). */
+export declare const LOCAL_PROVIDERS: LLMProviderName[];

package/dist/lib/setup/providerGlyphs.js

@@ -0,0 +1,42 @@
+/**
+ * Terminal brand marks for LLM providers (single-width glyphs + color).
+ */
+import { c, color, RESET } from "./ui/tokens.js";
+const MARKS = {
+    anthropic: { glyph: "◆", ansi: "\x1b[38;2;204;142;102m", shortName: "Anthropic" },
+    openai: { glyph: "◎", ansi: "\x1b[38;2;116;168;255m", shortName: "OpenAI" },
+    groq: { glyph: "⚡", ansi: "\x1b[38;2;255;200;87m", shortName: "Groq" },
+    xai: { glyph: "✕", ansi: "\x1b[38;2;230;230;230m", shortName: "xAI" },
+    mistral: { glyph: "◬", ansi: "\x1b[38;2;255;120;80m", shortName: "Mistral" },
+    openrouter: { glyph: "⬡", ansi: "\x1b[38;2;140;200;255m", shortName: "OpenRouter" },
+    ollama: { glyph: "○", ansi: c.ok, shortName: "Ollama" },
+    lmstudio: { glyph: "▣", ansi: c.ok, shortName: "LM Studio" },
+    custom: { glyph: "⚙", ansi: c.textMid, shortName: "Custom" },
+    skip: { glyph: "·", ansi: c.textGhost, shortName: "skip" },
+};
+const FALLBACK = { glyph: "•", ansi: c.textMid, shortName: "unknown" };
+export function getProviderMark(provider) {
+    return MARKS[provider] ?? FALLBACK;
+}
+/** Colored single-character (or short) logo for lists and tables. */
+export function renderProviderMark(provider) {
+    const m = getProviderMark(provider);
+    return `${m.ansi}${m.glyph}${RESET}`;
+}
+/** `◆ Anthropic` with brand-colored glyph. */
+export function renderProviderLabel(provider) {
+    const m = getProviderMark(provider);
+    return `${m.ansi}${m.glyph}${RESET} ${color(c.text, m.shortName)}`;
+}
+/** Cloud providers that use API keys in the providers screen. */
+export const CLOUD_PROVIDERS_FOR_KEYS = [
+    "anthropic",
+    "openai",
+    "groq",
+    "xai",
+    "mistral",
+    "openrouter",
+    "custom",
+];
+/** Local providers shown in the list (no key management). */
+export const LOCAL_PROVIDERS = ["ollama", "lmstudio"];

package/dist/lib/setup/remoteRender.d.ts

@@ -25,6 +25,20 @@ export interface ValidationSummaryInput {
     errors: string[];
 }
 export declare function renderValidationSummary(v: ValidationSummaryInput): string;
+/** Exact phrase required when declining automatic master backups (v13 design). */
+export declare const BACKUP_RISK_PHRASE = "I ACCEPT THE RISK OF DATA LOSS WITHOUT BACKUPS";
+/** Instruction shown when the user declines automatic master backups (v13 design). */
+export declare const BACKUP_DECLINE_ACK_INSTRUCTION = "If you answer No, you must type the following phrase to continue:";
+/** Guide URL for Tailscale setup (inline fallback when unreachable — todo 14). */
+export declare const TAILSCALE_GUIDE_URL = "https://gnosys.ai/docs/multi-machine-tailscale";
+/**
+ * v13 first screen — rules before master vs client (design doc §What Happens When…).
+ */
+export declare function renderV13ExplanationScreen(): string;
+/** Master backup acknowledgement block (v13 design). */
+export declare function renderMasterBackupWarning(): string;
+/** Typed-phrase prompt when the user disables automatic master backups (v13 design). */
+export declare function renderBackupDeclineAckPrompt(): string;
 /**
  * Render the leading Header + current-status line for the remote wizard.
  * Returns a multi-line string the wizard can print as-is.
@@ -37,6 +51,22 @@ export declare function renderRemoteIntro(localActive: number, localArchived: nu
 export interface RemoteDiffInput {
     previousRemote: string | null;
     newRemote: string;
-    mode: SyncMode;
+    /** v13 master/client role, or legacy sync mode label for older configs. */
+    roleOrMode: string;
+}
+/** Shown when the client cannot verify the master is reachable (~30s heartbeat). */
+export declare const MASTER_UNREACHABLE_MESSAGE = "Master unreachable; existing memories are unavailable until reconnect.";
+export declare function formatMemoriesWaitingToSync(count: number): string;
+export declare function formatFailedToSyncCount(count: number): string;
+/** Reconnect banner when offline-staged files are about to push (design doc). */
+export declare function formatOfflinePushStarting(count: number): string;
+export interface ClientSyncStatusInput {
+    masterReachable: boolean;
+    waitingToSync: number;
+    failedToSync: number;
+    /** Pending offline adds visible while disconnected (read-your-own-writes overlay). */
+    pendingOfflineAdds?: number;
 }
+/** Multi-line client sync status for panels, MCP, and CLI (pure strings). */
+export declare function renderClientSyncStatusLines(input: ClientSyncStatusInput): string[];
 export declare function renderRemoteDiff(d: RemoteDiffInput): string;

package/dist/lib/setup/remoteRender.js

@@ -34,6 +34,59 @@ export function renderValidationSummary(v) {
         lines.push(Status("fail", e));
     return lines.join("\n");
 }
+/** Exact phrase required when declining automatic master backups (v13 design). */
+export const BACKUP_RISK_PHRASE = "I ACCEPT THE RISK OF DATA LOSS WITHOUT BACKUPS";
+/** Instruction shown when the user declines automatic master backups (v13 design). */
+export const BACKUP_DECLINE_ACK_INSTRUCTION = "If you answer No, you must type the following phrase to continue:";
+/** Guide URL for Tailscale setup (inline fallback when unreachable — todo 14). */
+export const TAILSCALE_GUIDE_URL = "https://gnosys.ai/docs/multi-machine-tailscale";
+/**
+ * v13 first screen — rules before master vs client (design doc §What Happens When…).
+ */
+export function renderV13ExplanationScreen() {
+    const lines = [];
+    lines.push(Header(["gnosys", "setup", "multi-machine sync"]));
+    lines.push("");
+    lines.push(` ${color(c.text, "Multi-machine sync")}`);
+    lines.push("");
+    lines.push(` ${color(c.textDim, "Gnosys can share one brain across multiple machines, but only when they can all reach the same master folder.")}`);
+    lines.push("");
+    lines.push(` ${color(c.textDim, "This works best with a fast connection (Tailscale, good VPN, or machines on the same local network). Network shares like NAS or slow Tailscale mounts have caused timeouts and lost connections in practice.")}`);
+    lines.push("");
+    lines.push(` ${color(c.text, "When the master folder is reachable:")}`);
+    lines.push(` ${color(c.textDim, "  • Every machine reads from a published snapshot of the master (copied locally).")}`);
+    lines.push(` ${color(c.textDim, "  • New memories from client machines are staged as small files and later processed by the master (usually during idle time, invisibly).")}`);
+    lines.push("");
+    lines.push(` ${color(c.text, "When the master folder is NOT reachable:")}`);
+    lines.push(` ${color(c.textDim, "  • The machine can still write new memories into a small temporary cache.")}`);
+    lines.push(` ${color(c.textDim, "  • Old memories cannot be read.")}`);
+    lines.push(` ${color(c.textDim, "  • When the machine reconnects, it will quietly push the staged files so the master can ingest them.")}`);
+    return lines.join("\n");
+}
+/** Master backup acknowledgement block (v13 design). */
+export function renderMasterBackupWarning() {
+    const lines = [];
+    lines.push("");
+    lines.push(` ${color(c.text, "Master folder backup")}`);
+    lines.push("");
+    lines.push(` ${color(c.textDim, "The master folder will become the ONLY copy of your brain.")}`);
+    lines.push(` ${color(c.textDim, "If this machine's disk fails, your data is lost unless you have a backup.")}`);
+    lines.push("");
+    lines.push(` ${color(c.textDim, "By default, Gnosys will automatically create daily snapshots of the master database (last 7 days) using SQLite's backup API and store them in master-folder/backups/.")}`);
+    lines.push("");
+    lines.push(` ${color(c.textDim, "These are local rollback snapshots for corruption or accidental deletion. They do not protect against disk failure.")}`);
+    lines.push("");
+    lines.push(` ${color(c.textDim, "You may optionally provide an off-disk backup location (e.g., external drive or cloud folder) for an extra copy that survives disk loss.")}`);
+    return lines.join("\n");
+}
+/** Typed-phrase prompt when the user disables automatic master backups (v13 design). */
+export function renderBackupDeclineAckPrompt() {
+    const lines = [];
+    lines.push("");
+    lines.push(` ${color(c.textDim, BACKUP_DECLINE_ACK_INSTRUCTION)}`);
+    lines.push(` ${color(c.text, BACKUP_RISK_PHRASE)}`);
+    return lines.join("\n");
+}
 /**
  * Render the leading Header + current-status line for the remote wizard.
  * Returns a multi-line string the wizard can print as-is.
@@ -43,22 +96,60 @@ export function renderRemoteIntro(localActive, localArchived, currentRemote) {
     lines.push(Header(["gnosys", "setup", "remote"]));
     lines.push("");
     lines.push(` ${color(c.text, "Multi-machine sync")}`);
-    lines.push(` ${color(c.textDim, "share your memory store across machines via a path on a NAS, iCloud, Dropbox, etc.")}`);
+    lines.push(` ${color(c.textDim, "reconfigure or disconnect your master folder (v13 master/client model)")}`);
     lines.push("");
     const remoteTxt = currentRemote ?? "not configured";
     lines.push(`   ${color(c.textDim, "local DB")}    ${color(c.text, `~/.gnosys/gnosys.db (${localActive} active, ${localArchived} archived)`)}`);
     lines.push(`   ${color(c.textDim, "current")}     ${color(c.text, remoteTxt)}`);
     return lines.join("\n");
 }
+// ─── v13 sync status copy (design doc — offline / staging / ingest) ─────
+/** Shown when the client cannot verify the master is reachable (~30s heartbeat). */
+export const MASTER_UNREACHABLE_MESSAGE = "Master unreachable; existing memories are unavailable until reconnect.";
+export function formatMemoriesWaitingToSync(count) {
+    const n = Math.max(0, Math.floor(count));
+    return `${n} ${n === 1 ? "memory" : "memories"} waiting to sync`;
+}
+export function formatFailedToSyncCount(count) {
+    const n = Math.max(0, Math.floor(count));
+    return `${n} failed to sync`;
+}
+/** Reconnect banner when offline-staged files are about to push (design doc). */
+export function formatOfflinePushStarting(count) {
+    const n = Math.max(0, Math.floor(count));
+    return `Found ${n} ${n === 1 ? "memory" : "memories"} written while offline. Starting a background task to add them to the master brain.`;
+}
+/** Multi-line client sync status for panels, MCP, and CLI (pure strings). */
+export function renderClientSyncStatusLines(input) {
+    const lines = [];
+    if (!input.masterReachable) {
+        lines.push(Status("warn", MASTER_UNREACHABLE_MESSAGE));
+        if ((input.pendingOfflineAdds ?? 0) > 0) {
+            const n = input.pendingOfflineAdds;
+            lines.push(Status("progress", `Offline — ${n} new ${n === 1 ? "memory" : "memories"} queued locally; older memories hidden until reconnect.`));
+        }
+        else {
+            lines.push(Status("warn", "Offline — only new memories can be added until the master folder is reachable again."));
+        }
+        return lines;
+    }
+    if (input.waitingToSync > 0) {
+        lines.push(Status("progress", formatMemoriesWaitingToSync(input.waitingToSync)));
+    }
+    if (input.failedToSync > 0) {
+        lines.push(Status("fail", formatFailedToSyncCount(input.failedToSync), "gnosys sync doctor"));
+    }
+    return lines;
+}
 export function renderRemoteDiff(d) {
     const lines = [];
     const indent = "   ";
     const arrow = color(c.textGhost, glyph.arrow);
     const fromR = color(c.textMid, (d.previousRemote ?? "not configured").padEnd(20));
-    const labelR = color(c.textDim, "remote".padEnd(8));
+    const labelR = color(c.textDim, "master".padEnd(8));
     lines.push(`${indent}${labelR}   ${fromR}   ${arrow}   ${color(c.accentHi, d.newRemote)}`);
-    const labelM = color(c.textDim, "mode".padEnd(8));
+    const labelM = color(c.textDim, "role".padEnd(8));
     const fromM = color(c.textMid, "—".padEnd(20));
-    lines.push(`${indent}${labelM}   ${fromM}   ${arrow}   ${color(c.accentHi, d.mode)}`);
+    lines.push(`${indent}${labelM}   ${fromM}   ${arrow}   ${color(c.accentHi, d.roleOrMode)}`);
     return lines.join("\n");
 }

package/dist/lib/setup/sections/providers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Setup: Providers — API keys and provider credentials.
+ *
+ * `gnosys setup providers` or summary menu row "providers".
+ */
+import type { Interface as ReadlineInterface } from "readline/promises";
+import { type GnosysConfig } from "../../config.js";
+export interface ProvidersSetupOptions {
+    rl: ReadlineInterface;
+    directory: string;
+}
+/**
+ * Providers + API key management screen.
+ */
+export declare function runProvidersSetup(opts: ProvidersSetupOptions): Promise<boolean>;
+/** Summary line: how many providers have keys. */
+export declare function describeProvidersSummary(cfg: GnosysConfig): Promise<string>;