@agentage/cli 0.26.0 → 0.27.0

package/dist/commands/daemon/daemon-cmd.js

@@ -83,23 +83,6 @@ const statusAction = async () => {
             console.log(`  ${v.vault.padEnd(16)} ${cadence.padEnd(12)} ${state}`);
         }
     }
-    if (sync?.couch && sync.couch.length > 0) {
-        console.log('couch sync');
-        for (const v of sync.couch) {
-            const cadence = v.intervalSeconds > 0 ? `every ${v.intervalSeconds}s` : 'manual';
-            const state = v.paused
-                ? `paused: ${v.paused}`
-                : v.running
-                    ? 'running'
-                    : v.lastError
-                        ? `error: ${v.lastError}`
-                        : v.lastSync
-                            ? `ok ${v.lastSync}`
-                            : 'scheduled';
-            const pending = v.pendingCount > 0 ? `  ${v.pendingCount} pending` : '';
-            console.log(`  ${v.vault.padEnd(16)} ${cadence.padEnd(12)} ${state}${pending}`);
-        }
-    }
     if (sync?.discover && sync.discover.roots.length > 0) {
         console.log(`discover roots (${sync.discover.roots.length})`);
         for (const root of sync.discover.roots)

package/dist/commands/vault/vault-sync.d.ts

@@ -1,15 +1,13 @@
 import { type VaultsConfig } from '@agentage/memory-core';
-import { type SyncRunResult } from '../../lib/daemon/daemon-client.js';
 import { type SyncResult } from '../../sync/git/cycle.js';
-import { type CouchSyncResult } from '../../sync/couch/manager.js';
 import { type SyncTarget } from '../../sync/git/planner.js';
 export interface VaultSyncDeps {
     loadConfig: () => VaultsConfig;
     daemonPort: () => Promise<number | null>;
-    runViaDaemon: (port: number, vault: string) => Promise<SyncRunResult>;
+    runViaDaemon: (port: number, vault: string) => Promise<SyncResult>;
     runGitInProcess: (target: SyncTarget) => Promise<SyncResult>;
-    runCouchInProcess: (vault: string) => Promise<CouchSyncResult>;
     log: (msg: string) => void;
 }
+export declare const ACCOUNT_NO_CHANNEL = "not synced - account vaults have no sync channel";
 export declare const runVaultSync: (name: string | undefined, deps: VaultSyncDeps) => Promise<void>;
 export declare const defaultVaultSyncDeps: () => VaultSyncDeps;

package/dist/commands/vault/vault-sync.js

@@ -1,14 +1,13 @@
 import chalk from 'chalk';
+import { isAccountVault } from '@agentage/memory-core';
 import { health, syncRun } from '../../lib/daemon/daemon-client.js';
 import { daemonDisabled } from '../../lib/daemon/daemon-pref.js';
 import { loadVaultsConfig } from '../../lib/vault/vaults.js';
 import { resolvePort } from '../../daemon/lifecycle.js';
 import { runSyncCycle } from '../../sync/git/cycle.js';
-import { createCouchSyncManager } from '../../sync/couch/manager.js';
-import { couchTargets } from '../../sync/couch/targets.js';
 import { syncTargets } from '../../sync/git/planner.js';
 import { redactRemoteUrl } from '../../sync/git/remote-url.js';
-const isCouch = (r) => 'channel' in r && r.channel === 'couch';
+export const ACCOUNT_NO_CHANNEL = 'not synced - account vaults have no sync channel';
 const describeGit = (r) => {
     if (!r.ok)
         return chalk.red(`failed (${r.reason ?? 'error'})${r.error ? `: ${r.error}` : ''}`);
@@ -23,49 +22,43 @@ const describeGit = (r) => {
         bits.push('pushed');
     return chalk.green(bits.length ? bits.join(', ') : 'up to date');
 };
-const describeCouch = (r) => {
-    if (r.paused)
-        return chalk.yellow(`paused (${r.paused})`);
-    if (!r.ok)
-        return chalk.red(`failed${r.error ? `: ${r.error}` : ''}`);
-    const bits = [];
-    if (r.committed)
-        bits.push('committed');
-    if (r.pulled)
-        bits.push('pulled');
-    if (r.pendingCount)
-        bits.push(`${r.pendingCount} pending`);
-    return chalk.green(bits.length ? bits.join(', ') : 'up to date');
-};
 const report = (log, r) => {
-    if (isCouch(r)) {
-        log(`${r.vault} (account): ${describeCouch(r)}`);
-        return;
-    }
     log(`${r.vault} -> ${redactRemoteUrl(r.remote)}: ${describeGit(r)}`);
     for (const c of r.conflicts)
         log(`  kept remote copy: ${c}`);
 };
-// `agentage vault sync [name]`: sync one vault (or every syncable vault). Git-origin vaults
-// commit + push + pull-rebase; account (agentage) vaults sync the couch channel. Prefers a running
-// daemon (single writer), else runs the cycle in-process. Works for interval-0 (manual-only) vaults
-// and with the daemon down. Failures are surfaced, not thrown (V6: never a crash).
+// Account vaults whose only origin is the reserved `agentage` remote: nothing syncs them. They are
+// named, never silently skipped, so `vault sync` cannot read as "everything is up to date".
+const unsyncableAccountVaults = (config, gitTargets) => {
+    const git = new Set(gitTargets.map((t) => t.vault));
+    return Object.entries(config.vaults ?? {})
+        .filter(([vault, entry]) => isAccountVault(entry) && !git.has(vault))
+        .map(([vault]) => vault);
+};
+const reportAccounts = (log, vaults) => {
+    for (const vault of vaults)
+        log(`${vault} (account): ${chalk.yellow(ACCOUNT_NO_CHANNEL)}`);
+};
+// `agentage vault sync [name]`: sync one vault (or every syncable vault). Git-origin vaults commit
+// + push + pull-rebase; account (agentage) vaults have no sync channel and are reported as such.
+// Prefers a running daemon (single writer), else runs the cycle in-process. Works for interval-0
+// (manual-only) vaults and with the daemon down. Failures are surfaced, not thrown (V6: never a crash).
 export const runVaultSync = async (name, deps) => {
     const config = deps.loadConfig();
     // A named vault that is not registered is an error (mirrors `vault remove`), not a silent no-op.
     if (name && !(config.vaults ?? {})[name])
         throw new Error(`vault '${name}' not found`);
     const gitTargets = syncTargets(config).filter((t) => !name || t.vault === name);
-    const couchVaults = couchTargets(config)
-        .filter((t) => !name || t.vault === name)
-        .map((t) => t.vault);
-    if (gitTargets.length === 0 && couchVaults.length === 0) {
-        deps.log(name
-            ? `No syncable origin configured for vault '${name}'.`
-            : 'No syncable vaults. Add one with `agentage vault add <name>`.');
+    const accounts = unsyncableAccountVaults(config, gitTargets).filter((v) => !name || v === name);
+    if (gitTargets.length === 0) {
+        reportAccounts(deps.log, accounts);
+        if (accounts.length === 0)
+            deps.log(name
+                ? `No syncable origin configured for vault '${name}'.`
+                : 'No syncable vaults. Add one with `agentage vault add <name>`.');
         return;
     }
-    const vaults = [...new Set([...gitTargets.map((t) => t.vault), ...couchVaults])];
+    const vaults = [...new Set(gitTargets.map((t) => t.vault))];
     deps.log(`Syncing ${vaults.length} vault(s)...`);
     const port = await deps.daemonPort();
     if (port !== null) {
@@ -73,16 +66,14 @@ export const runVaultSync = async (name, deps) => {
             deps.log(`${vault}...`);
             report(deps.log, await deps.runViaDaemon(port, vault));
         }
-        return;
-    }
-    for (const target of gitTargets) {
-        deps.log(`${target.vault}...`);
-        report(deps.log, await deps.runGitInProcess(target));
     }
-    for (const vault of couchVaults) {
-        deps.log(`${vault}...`);
-        report(deps.log, await deps.runCouchInProcess(vault));
+    else {
+        for (const target of gitTargets) {
+            deps.log(`${target.vault}...`);
+            report(deps.log, await deps.runGitInProcess(target));
+        }
     }
+    reportAccounts(deps.log, accounts);
 };
 const resolveDaemonPort = async () => {
     if (daemonDisabled())
@@ -95,6 +86,5 @@ export const defaultVaultSyncDeps = () => ({
     daemonPort: resolveDaemonPort,
     runViaDaemon: syncRun,
     runGitInProcess: runSyncCycle,
-    runCouchInProcess: (vault) => createCouchSyncManager().runNow(vault),
     log: (msg) => console.log(msg),
 });

package/dist/commands/vault/vault.js

@@ -28,7 +28,8 @@ const buildEntry = (name, opts) => {
         const path = typeof opts.local === 'string' ? opts.local : `~/vaults/${name}`;
         return { path, mcp: ['local'] };
     }
-    // No --local/--git: an account vault - a local mirror synced to the account (agentage) channel.
+    // No --local/--git: an account vault - a local folder plus a memory in your account; this CLI
+    // has no channel that syncs the two.
     return { path: opts.path ?? `~/vaults/${name}`, origin: [{ remote: 'agentage' }] };
 };
 export const runVaultAdd = async (name, opts, deps = defaultDeps) => {
@@ -120,7 +121,7 @@ export const registerVault = (program) => {
         .action((name) => guardAsync(() => runVaultRemove(name)));
     vault
         .command('sync [name]')
-        .description('Sync vaults now (git commit/push/pull, or the account channel)')
+        .description('Sync vaults now (git commit/push/pull)')
         .action((name) => runVaultSync(name, defaultVaultSyncDeps()).catch((err) => {
         console.error(chalk.red(err instanceof Error ? err.message : String(err)));
         process.exitCode = 1;

package/dist/daemon/server.d.ts

@@ -2,18 +2,15 @@ import { type Server } from 'node:http';
 import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type MemoryClient } from '../lib/memory/memory-client.js';
 import { type SyncResult } from '../sync/git/cycle.js';
-import { type CouchSyncResult } from '../sync/couch/manager.js';
 import { type SyncStatus } from '../sync/git/manager.js';
-import { type MemoryVerb } from './actions.js';
 export interface DaemonSyncApi {
     status: () => SyncStatus;
-    runNow: (vault: string) => Promise<SyncResult | CouchSyncResult>;
+    runNow: (vault: string) => Promise<SyncResult>;
 }
 export interface DaemonServerOptions {
     getClient: () => MemoryClient | Promise<MemoryClient>;
     buildMcpServer?: () => Promise<McpServer>;
     sync?: DaemonSyncApi;
-    onMutation?: (verb: MemoryVerb, body: unknown) => void;
     authToken: string;
     version: string;
     startedAt?: number;

package/dist/daemon/server.js

@@ -93,7 +93,6 @@ export const createDaemonServer = (opts) => {
                 const body = await readBody(req);
                 const result = await dispatchMemory(await opts.getClient(), verb, body);
                 served += 1;
-                opts.onMutation?.(verb, body); // fire-and-forget account push-on-save
                 return send(res, 200, result);
             }
             catch (err) {

package/dist/daemon-entry.js

@@ -1,12 +1,10 @@
 import { unwatchFile, watchFile } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { isAccountVault } from '@agentage/memory-core';
 import { createClientProvider } from './daemon/client-provider.js';
 import { EADDRINUSE_EXIT_CODE, generateDaemonToken, removePidFile, removePortFile, removeTokenFile, resolvePort, writePidFile, writePortFile, writeTokenFile, } from './daemon/lifecycle.js';
 import { createDaemonServer } from './daemon/server.js';
 import { loadLocalMemoryServer } from './mcp/local-server.js';
-import { loadVaultsConfig, vaultsJsonPath } from './lib/vault/vaults.js';
-import { createCouchSyncManager } from './sync/couch/manager.js';
+import { vaultsJsonPath } from './lib/vault/vaults.js';
 import { createDiscoverWatcher } from './sync/discover/watcher.js';
 import { createSyncManager } from './sync/git/manager.js';
 import { VERSION } from './utils/version.js';
@@ -26,7 +24,7 @@ export const createStateCleanup = (remove) => {
     };
 };
 // Run each reschedule independently: a transiently-invalid config edit must not crash the daemon or
-// stop the other channels rescheduling; the throwing one keeps its last-good schedule.
+// stop the others rescheduling; the throwing one keeps its last-good schedule.
 export const safeReschedule = (steps, onError) => {
     for (const step of steps) {
         try {
@@ -55,30 +53,23 @@ const state = createStateCleanup(() => {
 });
 // The detached, long-lived engine host: one loopback HTTP server that owns a single in-process
 // engine and serialises every vault mutation, avoiding concurrent git index.lock collisions. It
-// runs both sync loops (git origins + the account/couch channel) and reschedules on config change.
+// runs the git sync loop and reschedules on config change.
 const main = async () => {
     const port = resolvePort();
     const authToken = generateDaemonToken();
     const git = createSyncManager();
-    const couch = createCouchSyncManager();
     const discover = createDiscoverWatcher({
         log: (msg) => console.log(`[discover] ${msg}`),
         debounceMs: envInt('AGENTAGE_DISCOVER_DEBOUNCE_MS'),
         pollMs: envInt('AGENTAGE_DISCOVER_POLL_MS'),
     });
-    // A vault is on exactly one channel: an account (agentage) vault syncs over couch, else git.
-    const runNow = (vault) => {
-        const entry = loadVaultsConfig().config.vaults?.[vault];
-        return entry && isAccountVault(entry) ? couch.runNow(vault) : git.runNow(vault);
-    };
     const server = createDaemonServer({
         getClient: createClientProvider(),
         buildMcpServer: mcpEnabled() ? loadLocalMemoryServer : undefined,
         sync: {
-            status: () => ({ ...git.status(), couch: couch.status(), discover: discover.status() }),
-            runNow,
+            status: () => ({ ...git.status(), discover: discover.status() }),
+            runNow: (vault) => git.runNow(vault),
         },
-        onMutation: (verb, body) => couch.onWrite(verb, body),
         authToken,
         version: VERSION,
     });
@@ -87,14 +78,13 @@ const main = async () => {
     writePortFile(port);
     writeTokenFile(authToken);
     state.markOwned();
-    const reschedule = () => safeReschedule([() => git.reschedule(), () => couch.reschedule(), () => discover.reschedule()], (msg) => console.error(`[daemon] reschedule failed: ${msg}`));
+    const reschedule = () => safeReschedule([() => git.reschedule(), () => discover.reschedule()], (msg) => console.error(`[daemon] reschedule failed: ${msg}`));
     reschedule();
     const configPath = vaultsJsonPath();
     watchFile(configPath, { interval: 2000 }, reschedule);
     const shutdown = () => {
         unwatchFile(configPath);
         git.stop();
-        couch.stop();
         discover.stop();
         server.stop().finally(() => {
             state.cleanup();

package/dist/lib/auth/api.d.ts

@@ -2,7 +2,6 @@ import { type AuthState } from '../fs/config.js';
 import { type Links } from '../net/origins.js';
 export { AuthRequiredError, TransientAuthError } from './auth-errors.js';
 export declare const refreshOrThrow: (auth: AuthState, links: Links) => Promise<void>;
-export declare const currentBearer: (readAuth: () => AuthState | null, links: Links) => Promise<string | null>;
 export declare const authedGet: <T>(auth: AuthState, links: Links, url: string) => Promise<T>;
 export declare const authedPost: (auth: AuthState, links: Links, url: string, body: unknown) => Promise<Response>;
 export { introspectToken, type TokenSession } from './introspect.js';

package/dist/lib/auth/api.js

@@ -47,18 +47,6 @@ const tryRefresh = async (auth, links) => {
         return false;
     }
 };
-// The current OAuth bearer for background (couch) sync. Reads auth.json fresh on every call - the
-// user may sign in or out between ticks - and refreshes once when the stored token is past its
-// stated expiry. Returns null when signed out so a caller pauses with zero network, never throws.
-export const currentBearer = async (readAuth, links) => {
-    const auth = readAuth();
-    if (!auth?.tokens.accessToken)
-        return null;
-    const expired = auth.tokens.expiresAt !== undefined && auth.tokens.expiresAt <= Date.now();
-    if (expired && !(await tryRefresh(auth, links)))
-        return null;
-    return auth.tokens.accessToken;
-};
 // redirect: 'manual' so the bearer is never replayed to a redirect target; any 3xx is an error.
 const isRedirect = (res) => res.type === 'opaqueredirect' || (res.status >= 300 && res.status < 400);
 export const authedGet = async (auth, links, url) => {

package/dist/lib/auth/provision.d.ts

@@ -1,6 +1,6 @@
 import { type AuthState } from '../fs/config.js';
 import { type Links } from '../net/origins.js';
-export type ProvisionStatus = 'provisioned' | 'exists' | 'disabled' | 'conflict' | 'unauthenticated' | 'offline';
+export type ProvisionStatus = 'provisioned' | 'exists' | 'unauthenticated' | 'offline';
 export interface ProvisionResult {
     status: ProvisionStatus;
     message: string;

package/dist/lib/auth/provision.js

@@ -6,39 +6,28 @@ export const defaultProvisionDeps = () => ({
     links: () => buildLinks(siteFqdn()),
     post: authedPost,
 });
-// The API error envelope carries the code as `error.code` (or a top-level `code`); read it best
-// effort - a non-JSON body just yields undefined and the caller falls back to non-fatal.
-const errorCode = async (res) => {
-    try {
-        const body = (await res.json());
-        return body.error?.code ?? body.code;
-    }
-    catch {
-        return undefined;
-    }
-};
 const registeredLocally = (name, tail) => `Vault '${name}' registered locally${tail}`;
 export const provisionAccountVault = async (name, deps = defaultProvisionDeps()) => {
     const auth = deps.readAuth();
     if (!auth) {
         return {
             status: 'unauthenticated',
-            message: registeredLocally(name, ' - run `agentage setup` to sync.'),
+            message: registeredLocally(name, ' - run `agentage setup` to create it in your account.'),
         };
     }
     // A PAT is an MCP-surface credential; the backend REST provisioning endpoint rejects plain
-    // bearers (only session cookies), so it cannot provision an account channel. Fail clearly.
+    // bearers (only session cookies), so it cannot create the account memory. Fail clearly.
     if (auth.kind === 'pat') {
         return {
             status: 'unauthenticated',
-            message: registeredLocally(name, ' - account-channel provisioning needs an interactive session (run `agentage setup`); ' +
+            message: registeredLocally(name, ' - account provisioning needs an interactive session (run `agentage setup`); ' +
                 'a personal access token only authorizes memory (MCP) calls.'),
         };
     }
     const links = deps.links();
     let res;
     try {
-        res = await deps.post(auth, links, `${links.api}/memories`, { name, channel: 'couch' });
+        res = await deps.post(auth, links, `${links.api}/memories`, { name });
     }
     catch {
         return {
@@ -53,18 +42,7 @@ export const provisionAccountVault = async (name, deps = defaultProvisionDeps())
     if (res.status === 401)
         return {
             status: 'unauthenticated',
-            message: registeredLocally(name, ' - run `agentage setup` to sync.'),
-        };
-    const code = await errorCode(res);
-    if (res.status === 403 && code === 'CHANNEL_DISABLED')
-        return {
-            status: 'disabled',
-            message: registeredLocally(name, '. Account sync is not enabled on this server.'),
-        };
-    if (res.status === 409 && code === 'CHANNEL_CONFLICT')
-        return {
-            status: 'conflict',
-            message: registeredLocally(name, `. A memory named '${name}' already exists on another channel - not syncing.`),
+            message: registeredLocally(name, ' - run `agentage setup` to create it in your account.'),
         };
     // Any other status stays non-fatal: keep the local entry, let the daemon retry later.
     return { status: 'offline', message: registeredLocally(name, ' - will provision when online.') };

package/dist/lib/daemon/daemon-client.d.ts

@@ -1,7 +1,5 @@
 import { type SyncResult } from '../../sync/git/cycle.js';
-import { type CouchSyncResult } from '../../sync/couch/manager.js';
 import { type SyncStatus } from '../../sync/git/manager.js';
-export type SyncRunResult = SyncResult | CouchSyncResult;
 import { type MemoryClient } from '../memory/memory-client.js';
 export interface Health {
     ok: boolean;
@@ -13,7 +11,7 @@ export interface Health {
 }
 export declare const health: (port: number, timeoutMs?: number) => Promise<Health | null>;
 export declare const syncStatus: (port: number, timeoutMs?: number) => Promise<SyncStatus | null>;
-export declare const syncRun: (port: number, vault: string) => Promise<SyncRunResult>;
+export declare const syncRun: (port: number, vault: string) => Promise<SyncResult>;
 export declare const waitForHealth: (port: number, opts?: {
     timeoutMs?: number;
     intervalMs?: number;

package/dist/lib/daemon/daemon-client.js

@@ -47,8 +47,7 @@ export const syncStatus = async (port, timeoutMs = 1000) => {
         return null;
     }
 };
-// Ask the daemon to sync one vault now; the daemon runs the cycle in its own process. The result
-// shape depends on the vault's channel (git SyncResult vs account CouchSyncResult).
+// Ask the daemon to sync one vault now; the daemon runs the git cycle in its own process.
 export const syncRun = async (port, vault) => {
     const res = await fetch(`${base(port)}/api/sync/run`, {
         method: 'POST',

package/dist/lib/status/status-info.js

@@ -20,18 +20,20 @@ const checkSite = async (siteUrl, headers) => {
     const res = await fetchJsonUnref(siteUrl, 3000, headers);
     return res !== null;
 };
-// Fold the git + couch per-vault states into one summary: any error wins, then any in-flight
-// run, else ok. lastRun is the freshest reported; lastError the first seen.
+// Fold the per-vault git states into one summary: any error wins, then any in-flight run, else ok.
+// lastRun is the freshest reported; lastError the first seen. Account vaults are absent by design -
+// they have no sync channel, so they are never counted as synced here (the vaults block names them).
 const summarizeSync = (sync) => {
     const git = Array.isArray(sync.vaults) ? sync.vaults : [];
-    const couch = Array.isArray(sync.couch) ? sync.couch : [];
-    const vaults = git.length + couch.length;
-    const error = git.find((v) => v.lastError)?.lastError ?? couch.find((v) => v.lastError)?.lastError;
-    const running = git.some((v) => v.running) || couch.some((v) => v.running);
+    const error = git.find((v) => v.lastError)?.lastError;
+    const running = git.some((v) => v.running);
     const state = error ? 'error' : running ? 'syncing' : 'ok';
-    const runs = [...git.map((v) => v.lastRun), ...couch.map((v) => v.lastSync)].filter((r) => Boolean(r));
-    const lastRun = runs.sort().at(-1);
-    return { vaults, state, lastRun, lastError: error };
+    const lastRun = git
+        .map((v) => v.lastRun)
+        .filter((r) => Boolean(r))
+        .sort()
+        .at(-1);
+    return { vaults: git.length, state, lastRun, lastError: error };
 };
 const probeDaemon = async () => {
     const port = resolvePort();

package/dist/lib/status/vaults-format.js

@@ -21,12 +21,16 @@ const statusCell = (v) => {
             return `${mark(false)} error (${shortError(v.lastError)})`;
         case 'unknown':
             return chalk.dim('- unknown (daemon stopped)');
+        case 'unsynced':
+            return `${mark(false)} not synced - account vaults have no sync channel`;
         case 'idle':
             return v.channel === 'local' ? chalk.dim('- local only') : chalk.dim('- idle');
     }
 };
+// Only git vaults are "connected": an account vault has no sync channel, so counting it would
+// re-tell the lie the per-vault row exists to correct.
 const countLabel = (vaults) => {
-    const connected = vaults.filter((v) => v.channel !== 'local').length;
+    const connected = vaults.filter((v) => v.channel === 'git').length;
     if (connected > 0)
         return `${connected} connected`;
     const n = vaults.length;
@@ -38,7 +42,8 @@ export const vaultLines = (vaults) => {
     if (vaults.length === 0)
         return [`${'vaults'.padEnd(10)} none - run: agentage vault add <name> --local`];
     const nameW = Math.max(...vaults.map((v) => v.name.length));
+    const chanW = Math.max(...vaults.map((v) => v.channel.length));
     const header = `${'vaults'.padEnd(10)} ${countLabel(vaults)}`;
-    const rows = vaults.map((v) => `  ${v.name.padEnd(nameW)}  ${v.channel.padEnd(6)} ${statusCell(v)}`);
+    const rows = vaults.map((v) => `  ${v.name.padEnd(nameW)}  ${v.channel.padEnd(chanW)} ${statusCell(v)}`);
     return [header, ...rows];
 };

package/dist/lib/status/vaults-status.d.ts

@@ -1,7 +1,7 @@
 import { type VaultsConfig } from '@agentage/memory-core';
 import { type SyncStatus } from '../../sync/git/manager.js';
-export type VaultChannel = 'local' | 'git' | 'cloud';
-export type VaultSyncState = 'ok' | 'syncing' | 'error' | 'idle' | 'unknown';
+export type VaultChannel = 'local' | 'git' | 'account';
+export type VaultSyncState = 'ok' | 'syncing' | 'error' | 'idle' | 'unknown' | 'unsynced';
 export interface VaultStatus {
     name: string;
     channel: VaultChannel;

package/dist/lib/status/vaults-status.js

@@ -1,19 +1,22 @@
 import { isAccountVault } from '@agentage/memory-core';
 import { loadVaultsConfig } from '../vault/vaults.js';
-// Config alone decides the channel: an `agentage` origin is the cloud (couch) channel, any other
-// origin is an external git remote, and no origin at all is a local-only vault (nothing to sync).
+// Config alone decides the channel: an external remote means git (it really syncs), else an
+// `agentage` origin means account, else local-only. External wins so a hand-edited entry carrying
+// both is reported by the channel that actually moves bytes.
 const channelOf = (entry) => {
-    if (isAccountVault(entry))
-        return 'cloud';
-    return entry.origin?.some((o) => o.remote.trim() && o.remote.trim() !== 'agentage')
-        ? 'git'
-        : 'local';
+    const external = entry.origin?.some((o) => o.remote.trim() && o.remote.trim() !== 'agentage');
+    if (external)
+        return 'git';
+    return isAccountVault(entry) ? 'account' : 'local';
 };
-// Live state from the daemon wins; a local-only vault is `idle` (nothing to sync), and any synced
-// vault with no daemon report is `unknown` (daemon down or the vault not yet scheduled).
+// Live state from the daemon wins; a local-only vault is `idle` (nothing to sync), an account vault
+// is always `unsynced` (it has no sync channel, so no daemon report can make it healthy), and any
+// git vault with no daemon report is `unknown` (daemon down or the vault not yet scheduled).
 const stateFrom = (channel, live, daemonUp) => {
     if (channel === 'local')
         return 'idle';
+    if (channel === 'account')
+        return 'unsynced';
     if (!daemonUp)
         return 'unknown';
     if (!live)
@@ -24,13 +27,11 @@ const stateFrom = (channel, live, daemonUp) => {
         return 'syncing';
     return live.lastRun ? 'ok' : 'idle';
 };
-// Index the daemon's per-vault reports by name across both channels into one lookup.
+// Index the daemon's per-vault git reports by name.
 const indexLive = (sync) => {
     const map = new Map();
     for (const v of sync?.vaults ?? [])
         map.set(v.vault, { running: v.running, lastError: v.lastError, lastRun: v.lastRun });
-    for (const c of sync?.couch ?? [])
-        map.set(c.vault, { running: c.running, lastError: c.lastError, lastRun: c.lastSync });
     return map;
 };
 // The full per-vault picture: every configured vault (so local-only vaults are never hidden),

package/dist/lib/vault/vault-registry.js

@@ -3,9 +3,8 @@ import { resolve } from 'node:path';
 import { expandPath, isAccountVault, validateConfig, } from '@agentage/memory-core';
 import { redactRemoteUrl } from '../../sync/git/remote-url.js';
 import { isValidVaultName } from './vaults.schema.js';
-// The human-facing type of an entry: an agentage origin is an account vault (local mirror +
-// cloud channel); otherwise a path with an external origin is git, a bare path is local, and an
-// origin without a path is remote.
+// The human-facing type of an entry: an agentage origin is an account vault; otherwise a path with
+// an external origin is git, a bare path is local, and an origin without a path is remote.
 export const vaultType = (entry) => {
     if (isAccountVault(entry))
         return 'account';

package/dist/sync/discover/watcher.js

@@ -80,7 +80,7 @@ export const createDiscoverWatcher = (deps = {}) => {
             return [];
         for (const c of added) {
             log(`discovered account vault '${c.name}' -> ${c.entry.path}`);
-            void provision(c.name).catch(() => { }); // never fatal: the couch loop re-provisions
+            void provision(c.name).catch(() => { }); // never fatal: the next scan re-provisions
         }
         return added;
     };

package/dist/sync/git/manager.d.ts

@@ -1,5 +1,4 @@
 import { type VaultsConfig } from '@agentage/memory-core';
-import { type CouchTargetStatus } from '../couch/manager.js';
 import { type DiscoverStatus } from '../discover/watcher.js';
 import { type SyncResult } from './cycle.js';
 import { type SyncTarget } from './planner.js';
@@ -14,7 +13,6 @@ export interface VaultSyncState {
 }
 export interface SyncStatus {
     vaults: VaultSyncState[];
-    couch?: CouchTargetStatus[];
     discover?: DiscoverStatus;
 }
 export interface SyncManagerDeps {

package/dist/sync/git/planner.js

@@ -7,15 +7,15 @@ export const DEFAULT_INTERVAL_SECONDS = 300;
 // When `ignore` is absent these editor/runtime files are excluded from sync; a set value REPLACES
 // the defaults, and an empty array syncs everything.
 export const DEFAULT_IGNORE = ['.obsidian/', 'data.json'];
-// The reserved cloud channel is never synced over external git (that path is out of scope here).
+// The reserved account remote is a sentinel, not a URL: never synced over external git.
 const RESERVED_REMOTE = 'agentage';
 export const resolveIgnore = (ignore) => ignore === undefined ? [...DEFAULT_IGNORE] : ignore;
 export const intervalMs = (seconds) => Math.max(0, Math.floor(seconds)) * 1000;
 // One vault may carry several origins; each gets a distinct remote name within its own repo.
 const remoteNameFor = (index) => (index === 0 ? 'sync' : `sync-${index}`);
 // Flatten (vault, origin) pairs into sync targets. A target needs a local `path` (the working
-// copy to commit/push from) AND an external origin; origin-only entries (cloud remote backends)
-// and the reserved cloud channel are skipped.
+// copy to commit/push from) AND an external origin; origin-only entries (remote backends) and the
+// reserved account remote are skipped.
 export const syncTargets = (config) => {
     const out = [];
     for (const [vault, entry] of Object.entries(config.vaults ?? {})) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentage/cli",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "The agentage CLI - connect this machine to agentage from the terminal",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,15 +40,15 @@
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {
-    "@agentage/memory-core": "^0.4.0",
-    "@agentage/server-memory": "^0.2.0",
+    "@agentage/memory-core": "^0.5.0",
+    "@agentage/server-memory": "^0.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "open": "^11.0.0"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.115.0",
+    "@anthropic-ai/sdk": "0.116.0",
     "@playwright/test": "latest",
     "@types/node": "latest",
     "@typescript-eslint/eslint-plugin": "latest",

package/dist/sync/couch/cycle.d.ts

@@ -1,2 +0,0 @@
-import { type CouchRuntime, type CouchSyncResult, type TargetState } from './manager.types.js';
-export declare const runCouchCycle: (rt: CouchRuntime, st: TargetState) => Promise<CouchSyncResult>;