@agentage/cli 0.37.2 → 0.38.0

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

@@ -1,136 +0,0 @@
-import { spawn as spawnChild } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import chalk from 'chalk';
-import { EADDRINUSE_EXIT_CODE, readDaemonToken, resolvePort } from '../../daemon/lifecycle.js';
-import { daemonServiceName } from '../../observability.js';
-import { VERSION } from '../../utils/version.js';
-const base = (port) => `http://127.0.0.1:${port}`;
-// The 0600 token file is the daemon's auth: read it fresh per call so a restart's new token is
-// picked up; absent means we cannot authenticate, so /api/* will 401 and callers fall back.
-const apiHeaders = () => {
-    const token = readDaemonToken();
-    return { 'Content-Type': 'application/json', ...(token ? { 'X-Agentage-Token': token } : {}) };
-};
-const post = async (port, verb, body) => {
-    const res = await fetch(`${base(port)}/api/memory/${verb}`, {
-        method: 'POST',
-        headers: apiHeaders(),
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-        const data = (await res.json().catch(() => ({})));
-        throw new Error(data.error || `daemon request failed: ${res.status}`);
-    }
-    return res.json();
-};
-export const health = async (port, timeoutMs = 1000) => {
-    try {
-        const res = await fetch(`${base(port)}/api/health`, {
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        return res.ok ? (await res.json()) : null;
-    }
-    catch {
-        return null;
-    }
-};
-// Read the daemon's per-vault sync state (last run, last error); null when the endpoint is absent
-// (an older daemon) or unreachable.
-export const syncStatus = async (port, timeoutMs = 1000) => {
-    try {
-        const res = await fetch(`${base(port)}/api/sync/status`, {
-            headers: apiHeaders(),
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        return res.ok ? (await res.json()) : null;
-    }
-    catch {
-        return null;
-    }
-};
-// 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',
-        headers: apiHeaders(),
-        body: JSON.stringify({ vault }),
-    });
-    if (!res.ok) {
-        const data = (await res.json().catch(() => ({})));
-        throw new Error(data.error || `sync request failed: ${res.status}`);
-    }
-    return res.json();
-};
-export const waitForHealth = async (port, opts = {}) => {
-    const intervalMs = opts.intervalMs ?? 100;
-    const deadline = Date.now() + (opts.timeoutMs ?? 4000);
-    while (Date.now() < deadline) {
-        if (await health(port, intervalMs + 200))
-            return true;
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
-    return false;
-};
-// A thin MemoryClient over HTTP: every method is a pass-through POST; the daemon's in-process
-// DirectClient does the vault scoping, so the wire carries the raw ref + opts unchanged.
-export const createDaemonClient = (port) => ({
-    search: (query, opts) => post(port, 'search', { query, opts }),
-    read: (ref, opts) => post(port, 'read', { ref, opts }),
-    write: (ref, body, opts) => post(port, 'write', { ref, body, opts }),
-    edit: (ref, op, opts) => post(port, 'edit', { ref, op, opts }),
-    list: (folder, opts) => post(port, 'list', { folder, opts }),
-    delete: (ref, opts) => post(port, 'delete', { ref, opts }),
-});
-// A restart hint when the running daemon predates the current binary.
-export const mismatchNotice = (daemonVersion) => daemonVersion === VERSION
-    ? null
-    : `daemon version ${daemonVersion} != cli ${VERSION}; restart with: agentage daemon stop && agentage daemon start`;
-const entryPath = () => fileURLToPath(new URL('../../daemon-entry.js', import.meta.url));
-// Detached spawn (not fork: fork's IPC channel keeps the parent event loop alive past unref) so
-// the daemon outlives this CLI; ignore stdio + unref so the CLI can exit. Watches the child's exit
-// so a fast EADDRINUSE death short-circuits the health wait instead of burning the full timeout.
-export const spawnDaemon = async (port, opts = {}) => {
-    let child;
-    try {
-        child = spawnChild(process.execPath, [entryPath()], {
-            detached: true,
-            stdio: 'ignore',
-            env: {
-                ...process.env,
-                AGENTAGE_DAEMON_PORT: String(port),
-                // Its own service in telemetry: never inherit the name we defaulted into the CLI's env.
-                OTEL_SERVICE_NAME: daemonServiceName(),
-                ...(opts.noMcp ? { AGENTAGE_DAEMON_NO_MCP: '1' } : {}),
-            },
-        });
-    }
-    catch {
-        return { ok: false, reason: 'blocked' };
-    }
-    const exited = new Promise((resolve) => {
-        child.once('exit', (code) => resolve({ ok: false, reason: code === EADDRINUSE_EXIT_CODE ? 'port-in-use' : 'unreachable' }));
-    });
-    child.unref();
-    const healthy = waitForHealth(port, { timeoutMs: opts.timeoutMs ?? 4000 }).then((ok) => (ok ? { ok: true } : { ok: false, reason: 'unreachable' }));
-    return Promise.race([healthy, exited]);
-};
-// DO3/DO4/DO9: prefer a live daemon, autostart one if absent, and return null when it is
-// unreachable, cannot be spawned, or has no readable token (nothing to authenticate with) so the
-// caller falls back to the in-process DirectClient.
-export const ensureDaemon = async (deps = {}) => {
-    const port = deps.port ?? resolvePort();
-    const probe = deps.probe ?? health;
-    const spawn = deps.spawn ?? spawnDaemon;
-    const readToken = deps.readToken ?? readDaemonToken;
-    const existing = await probe(port);
-    if (existing) {
-        if (!readToken())
-            return null;
-        const notice = mismatchNotice(existing.version);
-        if (notice)
-            console.error(chalk.yellow(notice));
-        return createDaemonClient(port);
-    }
-    const outcome = await spawn(port).catch(() => ({ ok: false, reason: 'blocked' }));
-    return outcome.ok && readToken() ? createDaemonClient(port) : null;
-};

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

@@ -1,2 +0,0 @@
-export declare const disableDaemon: () => void;
-export declare const daemonDisabled: () => boolean;

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

@@ -1,10 +0,0 @@
-// Whether the memory verbs must run in-process (DirectClient) instead of via the daemon.
-// Set by the `--no-daemon` global flag or AGENTAGE_NO_DAEMON=1 (tests/sandbox/CI).
-let forced = false;
-export const disableDaemon = () => {
-    forced = true;
-};
-export const daemonDisabled = () => {
-    const env = process.env['AGENTAGE_NO_DAEMON'];
-    return forced || env === '1' || env === 'true';
-};

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

@@ -1,30 +0,0 @@
-import { type EditInput, type ListResult, type MemoryView, type SearchResult, type VaultsConfig, type WriteResult } from '@agentage/memory-core';
-export interface DeleteResult {
-    path: string;
-    deleted: boolean;
-}
-export declare const translateEngineMessage: (message: string) => string;
-export interface VerbOptions {
-    vault?: string;
-}
-export interface SearchOptions extends VerbOptions {
-    folder?: string;
-    limit?: number;
-    tags?: string[];
-    cursor?: string;
-}
-export interface ListOptions extends VerbOptions {
-    depth?: 1 | 2;
-    tags?: string[];
-}
-export interface MemoryClient {
-    search(query: string, opts?: SearchOptions): Promise<SearchResult>;
-    read(ref: string, opts?: VerbOptions): Promise<MemoryView>;
-    write(ref: string, body: string, opts?: VerbOptions & {
-        frontmatter?: Record<string, unknown>;
-    }): Promise<WriteResult>;
-    edit(ref: string, op: Omit<EditInput, 'path'>, opts?: VerbOptions): Promise<WriteResult>;
-    list(folder: string | undefined, opts?: ListOptions): Promise<ListResult>;
-    delete(ref: string, opts?: VerbOptions): Promise<DeleteResult>;
-}
-export declare const createDirectClient: (config: VaultsConfig) => MemoryClient;

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

@@ -1,98 +0,0 @@
-import { createRegistry, createRouter, } from '@agentage/memory-core';
-// Engine (memory-core) messages leak MCP tool vocabulary (`memory__list`, ...) unfit for a terminal.
-// Rewrite the known patterns to CLI vocabulary at this seam; do not fork the engine.
-const ENGINE_MESSAGE_MAP = [
-    [
-        /Use memory__list with no folder to see available vaults\.?/g,
-        'Run `agentage vault list` to see available vaults.',
-    ],
-];
-export const translateEngineMessage = (message) => ENGINE_MESSAGE_MAP.reduce((m, [pattern, replacement]) => m.replace(pattern, replacement), message);
-// --vault becomes an @-prefix so the router resolves it; an explicit @<vault>/... passes through.
-const scopeRef = (ref, vault) => ref.startsWith('@') ? ref : vault ? `@${vault}/${ref}` : ref;
-const scopeFolder = (folder, vault) => {
-    if (vault)
-        return folder ? `@${vault}/${folder}` : `@${vault}`;
-    return folder || undefined;
-};
-export const createDirectClient = (config) => {
-    let ctxP;
-    const ctx = () => {
-        if (!ctxP) {
-            ctxP = (async () => {
-                const registry = await createRegistry(config);
-                // Offline engine: only local (git working-copy) backends are usable here.
-                const local = registry.list().filter((h) => h.backend.capabilities().kind === 'local');
-                if (local.length === 0)
-                    throw new Error('no local vaults registered - run `agentage vault add <name> --local`');
-                const def = registry.default();
-                const defaultHandle = def && local.some((h) => h.id === def.id) ? def : undefined;
-                return {
-                    router: createRouter(local, defaultHandle),
-                    multi: local.length > 1,
-                    hasDefault: !!defaultHandle,
-                };
-            })();
-            ctxP.catch(() => (ctxP = undefined));
-        }
-        return ctxP;
-    };
-    // A single-target verb on a bare ref needs a vault when >1 is registered and none is default.
-    const requireTarget = (ref, c) => {
-        if (c.multi && !c.hasDefault && !ref.startsWith('@'))
-            throw new Error('multiple vaults - use --vault <name>, @<vault>/<path>, or set "default" in vaults.json');
-    };
-    return {
-        async search(query, opts = {}) {
-            const { router } = await ctx();
-            return router.search({
-                query,
-                folder: scopeFolder(opts.folder, opts.vault),
-                tags: opts.tags,
-                limit: opts.limit,
-                cursor: opts.cursor,
-            });
-        },
-        async read(ref, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            const view = await c.router.read(target);
-            if (!view)
-                throw new Error(`not found: ${ref}`);
-            return view;
-        },
-        async write(ref, body, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            return c.router.write({ path: target, body, frontmatter: opts.frontmatter });
-        },
-        async edit(ref, op, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            const receipt = await c.router.edit({ ...op, path: target });
-            if (!receipt)
-                throw new Error(`not found: ${ref}`);
-            return receipt;
-        },
-        async list(folder, opts = {}) {
-            const { router } = await ctx();
-            return router.list({
-                folder: scopeFolder(folder, opts.vault),
-                depth: opts.depth,
-                tags: opts.tags,
-            });
-        },
-        async delete(ref, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            const deleted = await c.router.delete(target);
-            if (!deleted)
-                throw new Error(`not found: ${ref}`);
-            return { path: target, deleted };
-        },
-    };
-};

package/dist/lib/status/format.d.ts

@@ -1 +0,0 @@
-export declare const formatUptime: (seconds: number) => string;

package/dist/lib/status/format.js

@@ -1,12 +0,0 @@
-// Compact "Hh Mm" / "Mm Ss" uptime, matching the daemon and status rows. Seconds only under a
-// minute; hours dropped once zero so short-lived daemons read cleanly.
-export const formatUptime = (seconds) => {
-    const s = Math.max(0, Math.floor(seconds));
-    if (s < 60)
-        return `${s}s`;
-    const h = Math.floor(s / 3600);
-    const m = Math.floor((s % 3600) / 60);
-    if (h > 0)
-        return `${h}h ${m}m`;
-    return `${m}m ${s % 60}s`;
-};

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

@@ -1,2 +0,0 @@
-import { type VaultStatus } from './vaults-status.js';
-export declare const vaultLines: (vaults: VaultStatus[]) => string[];

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

@@ -1,49 +0,0 @@
-import chalk from 'chalk';
-const mark = (good) => (good ? chalk.green('✓') : chalk.red('✗'));
-// HH:MM in local time; a malformed timestamp falls back to the raw string so we never crash.
-const shortTime = (iso) => {
-    if (!iso)
-        return '';
-    const d = new Date(iso);
-    return Number.isNaN(d.getTime())
-        ? iso
-        : `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
-};
-const shortError = (err) => (err ?? 'sync failed').split('\n')[0]?.slice(0, 40) ?? 'sync failed';
-// One right-hand status cell per vault, sharing the check/cross marks with the other status rows.
-const statusCell = (v) => {
-    switch (v.status) {
-        case 'ok':
-            return `${mark(true)} last ok ${shortTime(v.lastRun)}`.trimEnd();
-        case 'syncing':
-            return `${chalk.yellow('⋯')} syncing`;
-        case 'error':
-            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 === 'git').length;
-    if (connected > 0)
-        return `${connected} connected`;
-    const n = vaults.length;
-    return `${n} ${n === 1 ? 'vault' : 'vaults'}`;
-};
-// The `vaults` block: a header count line then one aligned `<name> <channel> <status>` row per vault.
-// Zero vaults prints a single actionable hint instead of an empty block.
-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(chanW)} ${statusCell(v)}`);
-    return [header, ...rows];
-};

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

@@ -1,12 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-import { type SyncStatus } from '../../sync/git/manager.js';
-export type VaultChannel = 'local' | 'git' | 'account';
-export type VaultSyncState = 'ok' | 'syncing' | 'error' | 'idle' | 'unknown' | 'unsynced';
-export interface VaultStatus {
-    name: string;
-    channel: VaultChannel;
-    status: VaultSyncState;
-    lastRun?: string;
-    lastError?: string;
-}
-export declare const buildVaultStatuses: (sync: SyncStatus | null, daemonUp: boolean, config?: VaultsConfig) => VaultStatus[];

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

@@ -1,54 +0,0 @@
-import { isAccountVault } from '@agentage/memory-core';
-import { loadVaultsConfig } from '../vault/vaults.js';
-// 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) => {
-    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), 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)
-        return 'unknown';
-    if (live.lastError)
-        return 'error';
-    if (live.running)
-        return 'syncing';
-    return live.lastRun ? 'ok' : 'idle';
-};
-// 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 });
-    return map;
-};
-// The full per-vault picture: every configured vault (so local-only vaults are never hidden),
-// classified by channel and annotated with the daemon's live sync state when available.
-export const buildVaultStatuses = (sync, daemonUp, config = loadVaultsConfig().config) => {
-    const live = indexLive(sync);
-    return Object.entries(config.vaults ?? {})
-        .map(([name, entry]) => {
-        const channel = channelOf(entry);
-        const l = live.get(name);
-        return {
-            name,
-            channel,
-            status: stateFrom(channel, l, daemonUp),
-            lastRun: l?.lastRun,
-            lastError: l?.lastError,
-        };
-    })
-        .sort((a, b) => a.name.localeCompare(b.name));
-};

package/dist/lib/vault/vault-registry.d.ts

@@ -1,12 +0,0 @@
-import { type VaultEntry, type VaultsConfig } from '@agentage/memory-core';
-export type VaultType = 'account' | 'git' | 'local' | 'remote';
-export declare const vaultType: (entry: VaultEntry) => VaultType;
-export declare const ensureVaultDir: (path: string) => void;
-export declare const formatVaultLine: (name: string, entry: VaultEntry) => string;
-export declare const redactEntry: (entry: VaultEntry) => VaultEntry;
-export declare const addVault: (config: VaultsConfig, name: string, entry: VaultEntry) => VaultsConfig;
-export declare const removeVault: (config: VaultsConfig, name: string) => VaultsConfig;
-export declare const appendDiscoverIgnore: (config: VaultsConfig, name: string, vaultPath: string) => {
-    config: VaultsConfig;
-    root: string;
-} | null;

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

@@ -1,81 +0,0 @@
-import { existsSync, mkdirSync } from 'node:fs';
-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; 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';
-    if (entry.path)
-        return entry.origin?.length ? 'git' : 'local';
-    return 'remote';
-};
-// A local vault's markdown directory is created on `vault add` (~ is expanded).
-export const ensureVaultDir = (path) => {
-    const dir = expandPath(path);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-};
-export const formatVaultLine = (name, entry) => {
-    const kind = vaultType(entry);
-    const rawWhere = entry.path ? expandPath(entry.path) : (entry.origin?.[0]?.remote ?? '');
-    const where = entry.path ? rawWhere : redactRemoteUrl(rawWhere);
-    // Only an external git remote is worth echoing; the account channel is implied by the type.
-    const remote = kind === 'git' && entry.origin?.length
-        ? `  <- ${redactRemoteUrl(entry.origin[0].remote)}`
-        : '';
-    return `${name.padEnd(16)} ${kind.padEnd(8)} ${where}${remote}`;
-};
-// A copy of `entry` with every origin remote redacted (credentials stripped) for display/JSON;
-// the on-disk value is never mutated.
-export const redactEntry = (entry) => entry.origin?.length
-    ? { ...entry, origin: entry.origin.map((o) => ({ ...o, remote: redactRemoteUrl(o.remote) })) }
-    : entry;
-// Add an entry under `name`; the first vault added also becomes the `default`.
-export const addVault = (config, name, entry) => {
-    if (!isValidVaultName(name))
-        throw new Error(`invalid vault name: ${JSON.stringify(name)}`);
-    const vaults = config.vaults ?? {};
-    if (vaults[name])
-        throw new Error(`vault '${name}' already exists`);
-    return validateConfig({
-        ...config,
-        default: config.default ?? name,
-        vaults: { ...vaults, [name]: entry },
-    });
-};
-// Remove an entry; if it was the `default`, reassign to a remaining vault or drop the field.
-export const removeVault = (config, name) => {
-    const vaults = config.vaults ?? {};
-    if (!vaults[name])
-        throw new Error(`vault '${name}' not found`);
-    const rest = { ...vaults };
-    delete rest[name];
-    const next = { ...config, vaults: rest };
-    if (config.default === name) {
-        const fallback = Object.keys(rest)[0];
-        if (fallback)
-            next.default = fallback;
-        else
-            delete next.default;
-    }
-    return validateConfig(next);
-};
-// V8: when a removed vault sat directly under a discover root, append its name to that root's
-// `ignore` so the next scan does not re-add it. Returns the updated config plus the matched root
-// path (for the message), or null when the path is not directly under any discover root.
-export const appendDiscoverIgnore = (config, name, vaultPath) => {
-    const parent = resolve(expandPath(vaultPath), '..');
-    const roots = config.discover ?? [];
-    const idx = roots.findIndex((r) => resolve(expandPath(r.path)) === parent);
-    if (idx === -1)
-        return null;
-    const root = roots[idx];
-    if (root.ignore?.includes(name))
-        return { config, root: root.path };
-    const next = [...roots];
-    next[idx] = { ...root, ignore: [...(root.ignore ?? []), name] };
-    return { config: validateConfig({ ...config, discover: next }), root: root.path };
-};

package/dist/lib/vault/vaults.d.ts

@@ -1,10 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-export declare const vaultsJsonPath: () => string;
-export interface LoadedVaults {
-    config: VaultsConfig;
-    source: string | null;
-}
-export declare const loadVaultsConfig: () => LoadedVaults;
-export declare const ensureVaultsConfig: () => void;
-export declare const saveVaultsConfig: (config: VaultsConfig) => string;
-export declare const mutateVaultsConfig: (fn: (config: VaultsConfig) => VaultsConfig | null | void) => Promise<VaultsConfig>;

package/dist/lib/vault/vaults.js

@@ -1,66 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { validateConfig } from '@agentage/memory-core';
-import { ensureConfigDir, getConfigDir } from '../fs/config.js';
-import { withFileLock } from '../fs/file-lock.js';
-import { VAULTS_SCHEMA_URL } from './vaults.schema.js';
-export const vaultsJsonPath = () => join(getConfigDir(), 'vaults.json');
-const EMPTY = { version: 1, vaults: {} };
-// JSON only (one format everywhere; the standalone @agentage/server-memory reads the same file
-// and parses only JSON). A missing file yields an empty config; a bad shape throws ConfigError.
-export const loadVaultsConfig = () => {
-    const path = vaultsJsonPath();
-    if (!existsSync(path))
-        return { config: EMPTY, source: null };
-    const raw = JSON.parse(readFileSync(path, 'utf-8'));
-    return { config: validateConfig(raw), source: path };
-};
-// Scaffold an empty, $schema-linked vaults.json when none exists yet, so a fresh machine always
-// has an editable file with editor autocomplete. Leaves any existing file untouched.
-export const ensureVaultsConfig = () => {
-    if (existsSync(vaultsJsonPath()))
-        return;
-    saveVaultsConfig(EMPTY);
-};
-// Atomic 0600 write. Re-injects the canonical $schema first and preserves every other field.
-export const saveVaultsConfig = (config) => {
-    ensureConfigDir();
-    const path = vaultsJsonPath();
-    const out = { $schema: VAULTS_SCHEMA_URL, version: config.version };
-    if (config.vaultsDir !== undefined)
-        out.vaultsDir = config.vaultsDir;
-    if (config.autodiscover !== undefined)
-        out.autodiscover = config.autodiscover;
-    if (config.autoInit !== undefined)
-        out.autoInit = config.autoInit;
-    if (config.default !== undefined)
-        out.default = config.default;
-    if (config.discover !== undefined)
-        out.discover = config.discover;
-    out.vaults = config.vaults ?? {};
-    // A per-save tmp name: two concurrent savers can never clobber each other's tmp file.
-    const tmp = `${path}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
-    writeFileSync(tmp, JSON.stringify(out, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
-    renameSync(tmp, path);
-    chmodSync(path, 0o600);
-    return path;
-};
-// Cross-process-safe read-modify-write on vaults.json (issue #231). Under the advisory lock, re-read
-// FRESH from disk, apply `fn`, then atomic-save - so a concurrent `vault add` or the daemon's
-// discovery write-back can never clobber each other's update. `fn` may return a new config, mutate
-// the fresh one in place and return void, or return null to skip the write entirely (a no-op scan
-// must not re-touch the file, else the daemon's config watcher would loop). Returns the config on
-// disk after the call. A plain read stays lock-free via loadVaultsConfig.
-export const mutateVaultsConfig = async (fn) => {
-    ensureConfigDir();
-    return withFileLock(vaultsJsonPath(), () => {
-        const fresh = loadVaultsConfig().config;
-        const next = fn(fresh);
-        if (next === null)
-            return fresh; // explicit no-op: leave the file untouched
-        const result = next ?? fresh;
-        saveVaultsConfig(result);
-        return result;
-    });
-};

package/dist/lib/vault/vaults.schema.d.ts

@@ -1,2 +0,0 @@
-export declare const VAULTS_SCHEMA_URL = "https://agentage.io/schemas/vaults.schema.json";
-export { isValidVaultName, VAULT_NAME_PATTERN } from '@agentage/memory-core';

package/dist/lib/vault/vaults.schema.js

@@ -1,10 +0,0 @@
-// The vaults.json format is owned by @agentage/memory-core (validateConfig / VaultsConfig).
-// This module keeps the one CLI-surface piece memory-core does not: the editor-tooling $schema
-// pointer written on create. Name validation re-exports memory-core's single source of truth.
-// The public JSON Schema location (served by the landing). Written into the file on create so
-// editors get autocomplete + inline validation; accepted-and-ignored on load. A fixed
-// production URL by design: editor tooling fetches it regardless of the CLI's target FQDN.
-export const VAULTS_SCHEMA_URL = 'https://agentage.io/schemas/vaults.schema.json';
-// ADR-013 AA-4: every name stays a valid cloud path segment (`<sub>/<name>.git`). memory-core's
-// schema accepts any string key, so the CLI guards the name at the add surface with its allowlist.
-export { isValidVaultName, VAULT_NAME_PATTERN } from '@agentage/memory-core';

package/dist/mcp/local-server.d.ts

@@ -1,4 +0,0 @@
-import { type VaultRegistry } from '@agentage/memory-core';
-import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const createLocalMemoryServer: (registry: VaultRegistry) => McpServer;
-export declare const loadLocalMemoryServer: () => Promise<McpServer>;

package/dist/mcp/local-server.js

@@ -1,26 +0,0 @@
-import { createRegistry } from '@agentage/memory-core';
-import { createMemoryServer } from '@agentage/server-memory';
-import { loadVaultsConfig } from '../lib/vault/vaults.js';
-import { VERSION } from '../utils/version.js';
-// Restrict a registry to its offline (git working-copy) vaults, so the local MCP surface exposes
-// exactly what the DirectClient does - never a network-backed vault over the no-auth loopback.
-const localOnly = (registry) => {
-    const local = registry.list().filter((h) => h.backend.capabilities().kind === 'local');
-    const byId = new Map(local.map((h) => [h.id, h]));
-    const def = registry.default();
-    const defaultHandle = def && byId.has(def.id) ? def : undefined;
-    return {
-        list: () => local,
-        get: (id) => byId.get(id),
-        default: () => defaultHandle,
-        surfaced: () => local,
-        watch: () => () => { },
-        close: async () => { },
-    };
-};
-// Build the frozen 6-tool MCP server over one registry, reusing @agentage/server-memory's contract
-// layer verbatim (descriptions, schemas, annotations, per-connection instructions) - zero drift.
-export const createLocalMemoryServer = (registry) => createMemoryServer(localOnly(registry), { scope: 'local', version: VERSION });
-// The whole local stack: read this machine's vaults.json (the same config the daemon + CLI verbs
-// load) -> registry -> an MCP server over the surfaced local vaults.
-export const loadLocalMemoryServer = async () => createLocalMemoryServer(await createRegistry(loadVaultsConfig().config));

package/dist/observability.d.ts

@@ -1,4 +0,0 @@
-export declare const CLI_SERVICE = "agentage-cli";
-export declare const DAEMON_SERVICE = "agentage-daemon";
-export declare const daemonServiceName: () => string;
-export declare const startObservability: (service: string) => Promise<void>;