@agentage/cli 0.35.0 → 0.38.0

package/package.json

@@ -1,10 +1,21 @@
 {
   "name": "@agentage/cli",
-  "version": "0.35.0",
+  "version": "0.38.0",
   "description": "The agentage CLI - connect this machine to agentage from the terminal",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "default": "./dist/plugin.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "agentage": "./dist/cli.js"
   },
@@ -25,11 +36,11 @@
   },
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
-    "type-check": "tsc --noEmit",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "format": "prettier --write \"{src,e2e}/**/*.ts\"",
-    "format:check": "prettier --check \"{src,e2e}/**/*.ts\"",
+    "type-check": "tsc --noEmit && tsc -p fixtures",
+    "lint": "eslint src e2e fixtures",
+    "lint:fix": "eslint src e2e fixtures --fix",
+    "format": "prettier --write \"{src,e2e}/**/*.ts\" \"fixtures/**/*.{js,json}\"",
+    "format:check": "prettier --check \"{src,e2e}/**/*.ts\" \"fixtures/**/*.{js,json}\"",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -40,17 +51,11 @@
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {
-    "@agentage/memory-core": "^0.5.0",
-    "@agentage/observability": "^1.4.0",
-    "@agentage/server-memory": "^0.11.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opentelemetry/api": "^1.9.0",
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "open": "^11.0.0"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.131.0",
     "@playwright/test": "latest",
     "@types/node": "latest",
     "@typescript-eslint/eslint-plugin": "latest",

package/dist/commands/daemon/daemon-cmd.d.ts

@@ -1,2 +0,0 @@
-import { type Command } from 'commander';
-export declare const registerDaemon: (program: Command) => void;

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

@@ -1,107 +0,0 @@
-import chalk from 'chalk';
-import { isDaemonRunning, resolvePort, signalPid, stopDaemonSafely, } from '../../daemon/lifecycle.js';
-import { health, mismatchNotice, spawnDaemon, syncStatus } from '../../lib/daemon/daemon-client.js';
-const startAction = async (opts = {}) => {
-    const port = resolvePort();
-    const existing = await health(port);
-    if (existing) {
-        console.log(chalk.gray(`Daemon already running (pid ${existing.pid}, port ${port}).`));
-        return;
-    }
-    const noMcp = opts.mcp === false;
-    const outcome = await spawnDaemon(port, { noMcp });
-    if (!outcome.ok) {
-        if (outcome.reason === 'port-in-use') {
-            console.error(chalk.red(`Port ${port} is in use by another process - set AGENTAGE_DAEMON_PORT to use a different port.`));
-        }
-        else {
-            console.error(chalk.red('Daemon failed to start.'));
-        }
-        process.exitCode = 1;
-        return;
-    }
-    const h = await health(port);
-    const mcp = noMcp ? 'off' : 'on';
-    console.log(chalk.green(`Daemon started (pid ${h?.pid ?? '?'}, port ${port}, mcp ${mcp}).`));
-};
-// Detect the daemon the same way `start` does (tokenless /health), so a legacy daemon that never
-// wrote this config dir's pidfile is not misreported as "not running". With a pidfile we own, use
-// the safe pid-confirming stop; otherwise fall back to signalling the pid /health reports, or - if
-// none is available - report the truth rather than a false "not running".
-const stopAction = async () => {
-    if (isDaemonRunning()) {
-        if (await stopDaemonSafely())
-            console.log(chalk.green('Daemon stopped.'));
-        return;
-    }
-    const port = resolvePort();
-    const h = await health(port);
-    if (!h) {
-        console.log(chalk.gray('Daemon is not running.'));
-        return;
-    }
-    if (typeof h.pid === 'number' && signalPid(h.pid)) {
-        console.log(chalk.green(`Daemon stopped (pid ${h.pid}).`));
-        return;
-    }
-    const who = typeof h.pid === 'number' ? `pid ${h.pid}` : `port ${port}`;
-    console.error(chalk.yellow(`Daemon is running (${who}) but has no pidfile to stop it safely; stop it with: kill ${h.pid ?? '<pid>'}`));
-    process.exitCode = 1;
-};
-const statusAction = async () => {
-    const port = resolvePort();
-    const h = await health(port);
-    if (!h) {
-        console.log(isDaemonRunning()
-            ? chalk.yellow(`Daemon pid file present but unreachable on port ${port}.`)
-            : chalk.gray('Daemon is not running.'));
-        return;
-    }
-    console.log(`pid      ${h.pid ?? '?'}`);
-    console.log(`port     ${port}`);
-    if (typeof h.uptime === 'number')
-        console.log(`uptime   ${h.uptime}s`);
-    if (typeof h.served === 'number')
-        console.log(`served   ${h.served}`);
-    console.log(`mcp      ${h.mcp === false ? 'off' : 'on'}`);
-    console.log(`version  ${h.version}`);
-    const notice = mismatchNotice(h.version);
-    if (notice)
-        console.log(chalk.yellow(notice));
-    const sync = await syncStatus(port);
-    if (sync && sync.vaults.length > 0) {
-        console.log('sync');
-        for (const v of sync.vaults) {
-            const cadence = v.intervalSeconds > 0 ? `every ${v.intervalSeconds}s` : 'manual';
-            const state = v.running
-                ? 'running'
-                : v.lastError
-                    ? `error: ${v.lastError}`
-                    : v.lastRun
-                        ? `ok ${v.lastRun}`
-                        : 'scheduled';
-            console.log(`  ${v.vault.padEnd(16)} ${cadence.padEnd(12)} ${state}`);
-        }
-    }
-    if (sync?.discover && sync.discover.roots.length > 0) {
-        console.log(`discover roots (${sync.discover.roots.length})`);
-        for (const root of sync.discover.roots)
-            console.log(`  ${root}`);
-    }
-};
-export const registerDaemon = (program) => {
-    const daemon = program.command('daemon').description('Manage the local engine daemon');
-    daemon
-        .command('start')
-        .description('Start the daemon (idempotent)')
-        .option('--no-mcp', 'do not serve the local MCP endpoint at /mcp')
-        .action((opts) => startAction(opts));
-    daemon
-        .command('stop')
-        .description('Stop the daemon')
-        .action(() => stopAction());
-    daemon
-        .command('status')
-        .description('Show the daemon pid, uptime, and version')
-        .action(() => statusAction());
-};

package/dist/commands/memory/memory-verbs.d.ts

@@ -1,21 +0,0 @@
-import { type MemoryClient } from '../../lib/memory/memory-client.js';
-export interface CommonOpts {
-    vault?: string;
-    json?: boolean;
-}
-export declare const runSearch: (query: string, opts: CommonOpts & {
-    limit?: string;
-}, client?: MemoryClient) => Promise<void>;
-export declare const runRead: (ref: string, opts: CommonOpts, client?: MemoryClient) => Promise<void>;
-export declare const runWrite: (ref: string, opts: CommonOpts & {
-    body?: string;
-    frontmatter?: string;
-}, client?: MemoryClient) => Promise<void>;
-export declare const runEdit: (ref: string, opts: CommonOpts & {
-    old?: string;
-    new?: string;
-    body?: string;
-    append?: boolean;
-}, client?: MemoryClient) => Promise<void>;
-export declare const runList: (folder: string | undefined, opts: CommonOpts, client?: MemoryClient) => Promise<void>;
-export declare const runDelete: (ref: string, opts: CommonOpts, client?: MemoryClient) => Promise<void>;

package/dist/commands/memory/memory-verbs.js

@@ -1,98 +0,0 @@
-import chalk from 'chalk';
-import { ensureDaemon } from '../../lib/daemon/daemon-client.js';
-import { daemonDisabled } from '../../lib/daemon/daemon-pref.js';
-import { createDirectClient } from '../../lib/memory/memory-client.js';
-import { loadVaultsConfig } from '../../lib/vault/vaults.js';
-// Default engine path (DO3/DO4): the daemon - single writer, autostarted - when reachable; the
-// in-process DirectClient as a seamless fallback (--no-daemon, sandbox/CI, or fork blocked).
-const resolveClient = async () => {
-    const direct = () => createDirectClient(loadVaultsConfig().config);
-    if (daemonDisabled())
-        return direct();
-    const daemon = await ensureDaemon();
-    return daemon ?? direct();
-};
-const readStdin = async () => {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(chunk);
-    return Buffer.concat(chunks).toString('utf-8');
-};
-// --frontmatter must be a JSON object; a raw parser error or a non-object value is unfriendly.
-const parseFrontmatter = (raw) => {
-    if (!raw)
-        return undefined;
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        throw new Error(`--frontmatter must be a JSON object, e.g. '{"tags":["x"]}': ${detail}`);
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-        throw new Error(`--frontmatter must be a JSON object, e.g. '{"tags":["x"]}'`);
-    return parsed;
-};
-const emit = (json, data, human) => {
-    if (json)
-        console.log(JSON.stringify(data, null, 2));
-    else
-        human();
-};
-// Flatten a folder-tree to the file paths it contains, in tree order.
-const treeFiles = (entries) => entries.flatMap((e) => (e.type === 'file' ? [e.path] : e.entries ? treeFiles(e.entries) : []));
-export const runSearch = async (query, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const out = await c.search(query, {
-        vault: opts.vault,
-        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
-    });
-    emit(opts.json ?? false, out, () => {
-        if (out.results.length === 0)
-            console.log('No matches.');
-        for (const h of out.results)
-            console.log(`${h.path}\n  ${chalk.gray(h.snippet)}`);
-    });
-};
-export const runRead = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const doc = await c.read(ref, { vault: opts.vault });
-    emit(opts.json ?? false, doc, () => console.log(doc.body));
-};
-export const runWrite = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const inlineBody = opts.body !== undefined && opts.body !== '-';
-    if (!inlineBody && process.stdin.isTTY)
-        throw new Error('provide --body, or pipe content on stdin');
-    const body = inlineBody ? opts.body : await readStdin();
-    const frontmatter = parseFrontmatter(opts.frontmatter);
-    const out = await c.write(ref, body, { vault: opts.vault, frontmatter });
-    emit(opts.json ?? false, out, () => console.log(chalk.green(`Wrote ${out.path}`)));
-};
-export const runEdit = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    if (opts.old === undefined && opts.body === undefined)
-        throw new Error('specify --old/--new for a replacement or --body to overwrite');
-    const op = opts.old !== undefined
-        ? { mode: 'str_replace', old_str: opts.old, new_str: opts.new ?? '' }
-        : { mode: opts.append ? 'append' : 'replace', body: opts.body };
-    const out = await c.edit(ref, op, { vault: opts.vault });
-    emit(opts.json ?? false, out, () => console.log(chalk.green(`Edited ${out.path}`)));
-};
-export const runList = async (folder, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const out = await c.list(folder, { vault: opts.vault });
-    emit(opts.json ?? false, out, () => {
-        const files = treeFiles(out.entries);
-        if (files.length === 0)
-            console.log('No documents.');
-        for (const p of files)
-            console.log(p);
-    });
-};
-export const runDelete = async (ref, opts, client) => {
-    const c = client ?? (await resolveClient());
-    const out = await c.delete(ref, { vault: opts.vault });
-    emit(opts.json ?? false, out, () => console.log(`Deleted ${out.path} (recoverable from git history)`));
-};

package/dist/commands/memory/memory.d.ts

@@ -1,2 +0,0 @@
-import { type Command } from 'commander';
-export declare const registerMemory: (program: Command) => void;

package/dist/commands/memory/memory.js

@@ -1,54 +0,0 @@
-import chalk from 'chalk';
-import { translateEngineMessage } from '../../lib/memory/memory-client.js';
-import { runDelete, runEdit, runList, runRead, runSearch, runWrite, } from './memory-verbs.js';
-const guard = (fn) => fn().catch((err) => {
-    const message = translateEngineMessage(err instanceof Error ? err.message : String(err));
-    console.error(chalk.red(message));
-    process.exitCode = 1;
-});
-export const registerMemory = (program) => {
-    const memory = program.command('memory').description('Read + write memory, offline');
-    memory
-        .command('search <query...>')
-        .description('Search a vault (git grep)')
-        .option('--vault <name>', 'target vault')
-        .option('--limit <n>', 'max hits (default 20)')
-        .option('--json', 'machine-readable output')
-        .action((query, opts) => guard(() => runSearch(query.join(' '), opts)));
-    memory
-        .command('read <ref>')
-        .description('Print a document (@<vault>/<path> or <path> --vault)')
-        .option('--vault <name>', 'target vault')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runRead(ref, opts)));
-    memory
-        .command('write <ref>')
-        .description('Create or overwrite a document (body from --body or stdin)')
-        .option('--vault <name>', 'target vault')
-        .option('--body <text>', 'document body (omit or "-" to read stdin)')
-        .option('--frontmatter <json>', 'frontmatter as a JSON object')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runWrite(ref, opts)));
-    memory
-        .command('edit <ref>')
-        .description('Edit a document: str_replace (--old/--new) or --body (--append)')
-        .option('--vault <name>', 'target vault')
-        .option('--old <str>', 'exact, unique substring to replace')
-        .option('--new <str>', 'replacement (omit to delete the match)')
-        .option('--body <text>', 'replace the whole body')
-        .option('--append', 'append --body instead of replacing')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runEdit(ref, opts)));
-    memory
-        .command('list [folder]')
-        .description('List documents in a vault (optionally under a folder)')
-        .option('--vault <name>', 'target vault')
-        .option('--json', 'machine-readable output')
-        .action((folder, opts) => guard(() => runList(folder, opts)));
-    memory
-        .command('delete <ref>')
-        .description('Delete a document (recoverable from git history)')
-        .option('--vault <name>', 'target vault')
-        .option('--json', 'machine-readable output')
-        .action((ref, opts) => guard(() => runDelete(ref, opts)));
-};

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

@@ -1,13 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-import { type SyncResult } from '../../sync/git/cycle.js';
-import { type SyncTarget } from '../../sync/git/planner.js';
-export interface VaultSyncDeps {
-    loadConfig: () => VaultsConfig;
-    daemonPort: () => Promise<number | null>;
-    runViaDaemon: (port: number, vault: string) => Promise<SyncResult>;
-    runGitInProcess: (target: SyncTarget) => Promise<SyncResult>;
-    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,90 +0,0 @@
-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 { syncTargets } from '../../sync/git/planner.js';
-import { redactRemoteUrl } from '../../sync/git/remote-url.js';
-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}` : ''}`);
-    if (r.skipped)
-        return chalk.yellow(`skipped (${r.skipped})`);
-    const bits = [];
-    if (r.committed)
-        bits.push('committed');
-    if (r.conflicts.length)
-        bits.push(`${r.conflicts.length} conflict copy(ies)`);
-    if (r.pushed)
-        bits.push('pushed');
-    return chalk.green(bits.length ? bits.join(', ') : 'up to date');
-};
-const report = (log, r) => {
-    log(`${r.vault} -> ${redactRemoteUrl(r.remote)}: ${describeGit(r)}`);
-    for (const c of r.conflicts)
-        log(`  kept remote copy: ${c}`);
-};
-// 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 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))];
-    deps.log(`Syncing ${vaults.length} vault(s)...`);
-    const port = await deps.daemonPort();
-    if (port !== null) {
-        for (const vault of vaults) {
-            deps.log(`${vault}...`);
-            report(deps.log, await deps.runViaDaemon(port, 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())
-        return null;
-    const port = resolvePort();
-    return (await health(port)) ? port : null;
-};
-export const defaultVaultSyncDeps = () => ({
-    loadConfig: () => loadVaultsConfig().config,
-    daemonPort: resolveDaemonPort,
-    runViaDaemon: syncRun,
-    runGitInProcess: runSyncCycle,
-    log: (msg) => console.log(msg),
-});

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

@@ -1,22 +0,0 @@
-import { type Command } from 'commander';
-import { type VaultsConfig } from '@agentage/memory-core';
-import { type ProvisionResult } from '../../lib/auth/provision.js';
-import { type LoadedVaults } from '../../lib/vault/vaults.js';
-export interface VaultDeps {
-    load: () => LoadedVaults;
-    mutate: (fn: (config: VaultsConfig) => VaultsConfig | null | void) => Promise<VaultsConfig>;
-    ensureDir: (path: string) => void;
-    provision: (name: string) => Promise<ProvisionResult>;
-    log: (msg: string) => void;
-}
-export interface VaultAddOptions {
-    local?: string | boolean;
-    git?: string;
-    path?: string;
-}
-export declare const runVaultAdd: (name: string, opts: VaultAddOptions, deps?: VaultDeps) => Promise<void>;
-export declare const runVaultRemove: (name: string, deps?: VaultDeps) => Promise<void>;
-export declare const runVaultList: (opts: {
-    json?: boolean;
-}, deps?: VaultDeps) => void;
-export declare const registerVault: (program: Command) => void;

package/dist/commands/vault/vault.js

@@ -1,129 +0,0 @@
-import chalk from 'chalk';
-import { isAccountVault } from '@agentage/memory-core';
-import { addVault, appendDiscoverIgnore, ensureVaultDir, formatVaultLine, redactEntry, removeVault, vaultType, } from '../../lib/vault/vault-registry.js';
-import { defaultProvisionDeps, provisionAccountVault, } from '../../lib/auth/provision.js';
-import { loadVaultsConfig, mutateVaultsConfig } from '../../lib/vault/vaults.js';
-import { assertSafeRemoteUrl, redactRemoteUrl } from '../../sync/git/remote-url.js';
-import { defaultVaultSyncDeps, runVaultSync } from './vault-sync.js';
-const defaultDeps = {
-    load: loadVaultsConfig,
-    mutate: mutateVaultsConfig,
-    ensureDir: ensureVaultDir,
-    provision: (name) => provisionAccountVault(name, defaultProvisionDeps()),
-    log: (msg) => console.log(msg),
-};
-const buildEntry = (name, opts) => {
-    const hasLocal = opts.local !== undefined;
-    if (hasLocal && opts.git)
-        throw new Error('choose one of --local or --git, not both');
-    if (opts.path !== undefined && (hasLocal || opts.git))
-        throw new Error('--path applies only to an account vault (drop --local and --git)');
-    // A --git vault is a local working copy that syncs to an external git remote (path + origin);
-    // the daemon commits/pushes and pulls it per its interval.
-    if (opts.git) {
-        assertSafeRemoteUrl(opts.git);
-        return { path: `~/vaults/${name}`, origin: [{ remote: opts.git }], mcp: ['local'] };
-    }
-    if (hasLocal) {
-        const path = typeof opts.local === 'string' ? opts.local : `~/vaults/${name}`;
-        return { path, mcp: ['local'] };
-    }
-    // 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) => {
-    const entry = buildEntry(name, opts);
-    // The dup check + save run together under the lock, against the FRESH on-disk config.
-    await deps.mutate((config) => addVault(config, name, entry));
-    if (entry.path)
-        deps.ensureDir(entry.path);
-    const kind = vaultType(entry);
-    const where = entry.path ?? entry.origin?.[0]?.remote ?? '';
-    const via = kind === 'git' && entry.origin?.length ? ` <- ${redactRemoteUrl(entry.origin[0].remote)}` : '';
-    deps.log(chalk.green(`Added vault '${name}' (${kind}) -> ${where}${via}`));
-    // Offline-first: the local entry is saved first; provisioning the account channel is never fatal.
-    if (isAccountVault(entry))
-        deps.log((await deps.provision(name)).message);
-};
-export const runVaultRemove = async (name, deps = defaultDeps) => {
-    let wasDefault = false;
-    let ignoredRoot = null;
-    // The removal and the discover-ignore append run as one locked read-modify-write, against the
-    // FRESH on-disk config, else a concurrent writer's update is lost or the next scan re-adds the folder.
-    const next = await deps.mutate((config) => {
-        wasDefault = config.default === name;
-        const path = config.vaults?.[name]?.path;
-        let updated = removeVault(config, name);
-        const ignored = path ? appendDiscoverIgnore(updated, name, path) : null;
-        if (ignored) {
-            updated = ignored.config;
-            ignoredRoot = ignored.root;
-        }
-        return updated;
-    });
-    deps.log(`Removed vault '${name}' (files left on disk).`);
-    if (ignoredRoot)
-        deps.log(`Added '${name}' to ${ignoredRoot} ignore so it is not re-discovered.`);
-    if (wasDefault && next.default)
-        deps.log(`Default vault is now '${next.default}'.`);
-};
-export const runVaultList = (opts, deps = defaultDeps) => {
-    const { config } = deps.load();
-    const vaults = config.vaults ?? {};
-    const names = Object.keys(vaults);
-    if (opts.json) {
-        // Backward-compatible: still the name-keyed map, each entry annotated with its honest type.
-        // Origin remotes are redacted so a credentialed URL never leaks into machine output.
-        const out = Object.fromEntries(names.map((n) => [n, { ...redactEntry(vaults[n]), type: vaultType(vaults[n]) }]));
-        deps.log(JSON.stringify(out, null, 2));
-        return;
-    }
-    if (names.length === 0) {
-        deps.log('No vaults registered. Add one with `agentage vault add <name> --local`.');
-        return;
-    }
-    for (const name of names) {
-        const suffix = name === config.default ? '  (default)' : '';
-        deps.log(formatVaultLine(name, vaults[name]) + suffix);
-    }
-};
-const guard = (fn) => {
-    try {
-        fn();
-    }
-    catch (err) {
-        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-        process.exitCode = 1;
-    }
-};
-const guardAsync = (fn) => fn().catch((err) => {
-    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-    process.exitCode = 1;
-});
-export const registerVault = (program) => {
-    const vault = program.command('vault').description('Manage local memory vaults');
-    vault
-        .command('list')
-        .description('List registered vaults')
-        .option('--json', 'machine-readable output')
-        .action((opts) => guard(() => runVaultList(opts)));
-    vault
-        .command('add <name>')
-        .description('Register a vault (account by default; --local or --git for a self-hosted one)')
-        .option('--local [path]', 'a local folder (default ~/vaults/<name>)')
-        .option('--git <remote>', 'a vault synced to an external git remote')
-        .option('--path <dir>', 'account vault local mirror dir (default ~/vaults/<name>)')
-        .action((name, opts) => guardAsync(() => runVaultAdd(name, opts)));
-    vault
-        .command('remove <name>')
-        .description('Unregister a vault (files stay on disk)')
-        .action((name) => guardAsync(() => runVaultRemove(name)));
-    vault
-        .command('sync [name]')
-        .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/actions.d.ts

@@ -1,5 +0,0 @@
-import { type MemoryClient } from '../lib/memory/memory-client.js';
-export declare const MEMORY_VERBS: readonly ["search", "read", "write", "edit", "list", "delete"];
-export type MemoryVerb = (typeof MEMORY_VERBS)[number];
-export declare const isMemoryVerb: (v: string) => v is MemoryVerb;
-export declare const dispatchMemory: (client: MemoryClient, verb: MemoryVerb, body: unknown) => Promise<unknown>;

package/dist/daemon/actions.js

@@ -1,22 +0,0 @@
-export const MEMORY_VERBS = ['search', 'read', 'write', 'edit', 'list', 'delete'];
-export const isMemoryVerb = (v) => MEMORY_VERBS.includes(v);
-// Map one wire payload to the matching MemoryClient call. The daemon and the CLI share this verb
-// set so a daemon request runs the exact method a DirectClient would run in-process (DO2).
-export const dispatchMemory = (client, verb, body) => {
-    const p = (body ?? {});
-    switch (verb) {
-        case 'search':
-            return client.search(p['query'], p['opts']);
-        case 'read':
-            return client.read(p['ref'], p['opts']);
-        case 'write':
-            return client.write(p['ref'], p['body'], p['opts']);
-        case 'edit':
-            return client.edit(p['ref'], p['op'], p['opts']);
-        case 'list':
-            return client.list(p['folder'], p['opts']);
-        case 'delete':
-            return client.delete(p['ref'], p['opts']);
-    }
-    throw new Error(`unknown verb: ${verb}`);
-};

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

@@ -1,2 +0,0 @@
-import { type MemoryClient } from '../lib/memory/memory-client.js';
-export declare const createClientProvider: () => (() => MemoryClient);

package/dist/daemon/client-provider.js

@@ -1,16 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import { createDirectClient } from '../lib/memory/memory-client.js';
-import { loadVaultsConfig, vaultsJsonPath } from '../lib/vault/vaults.js';
-// One in-process engine per daemon, rebuilt only when vaults.json changes on disk, so a
-// `vault add` between requests is picked up without a daemon restart.
-export const createClientProvider = () => {
-    let cached;
-    return () => {
-        const path = vaultsJsonPath();
-        const mtime = existsSync(path) ? statSync(path).mtimeMs : 0;
-        if (!cached || cached.mtime !== mtime) {
-            cached = { client: createDirectClient(loadVaultsConfig().config), mtime };
-        }
-        return cached.client;
-    };
-};