@agentage/cli 0.37.2 → 0.38.1

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/update/update-lock.d.ts

@@ -1,2 +0,0 @@
-export declare const acquireUpdateLock: (now?: number) => boolean;
-export declare const releaseUpdateLock: () => void;

package/dist/lib/update/update-lock.js

@@ -1,109 +0,0 @@
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { ensureConfigDir, getConfigDir } from '../fs/config.js';
-const LOCK_FILE = 'update.lock';
-const LOCK_TTL_MS = 10 * 60 * 1000; // a lock older than this whose holder is gone is a crashed run
-// Past this age a holder is taken over even if its pid still resolves (pid reuse after a crash); far
-// beyond any real run or scheduler pause, so a live-but-slow holder is never mistaken for crashed.
-const STALE_HARD_MS = 30 * 60 * 1000;
-const lockPath = () => join(getConfigDir(), LOCK_FILE);
-// The lock file holds "<pid> <timestamp>": pid gates crash-takeover, the trailing token is the
-// acquisition time. A legacy single-token file parses as pid 0 (unknown holder), aging out on TTL.
-const holderOf = (path) => {
-    try {
-        const parts = readFileSync(path, 'utf-8').trim().split(/\s+/);
-        const at = Number.parseInt(parts[parts.length - 1] ?? '', 10);
-        if (Number.isNaN(at))
-            return null;
-        const pid = parts.length >= 2 ? Number.parseInt(parts[0] ?? '', 10) : 0;
-        return { pid: Number.isNaN(pid) ? 0 : pid, at };
-    }
-    catch {
-        return null;
-    }
-};
-// Same-host liveness probe. ESRCH = the holder is gone (crashed); EPERM = alive but owned by another
-// user. pid 0/unknown counts as gone so a legacy or malformed lock still ages out on the TTL.
-const holderAlive = (pid) => {
-    if (pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code === 'EPERM';
-    }
-};
-// A holder is safe to take over only once it is past the TTL AND provably gone: a dead pid, our own
-// leftover pid, or so old that pid reuse is the only explanation. A live holder merely starved of
-// CPU is never stolen - stealing it would let two writers run concurrently.
-const isCrashed = (holder, now) => {
-    const age = now - holder.at;
-    if (age < LOCK_TTL_MS)
-        return false;
-    if (age >= STALE_HARD_MS)
-        return true;
-    return holder.pid === process.pid || !holderAlive(holder.pid);
-};
-const unlinkQuiet = (path) => {
-    try {
-        unlinkSync(path);
-    }
-    catch {
-        // already gone
-    }
-};
-// Serialize stale-lock takeover behind its own exclusive create, so no taker can ever delete a
-// lock that turned FRESH mid-takeover (the ABA race: reader sees the stale timestamp, a winner
-// re-creates the lock, the reader deletes the winner's file). Under the guard the staleness is
-// re-checked and only a genuinely stale lock is cleared; losers simply refuse. A guard left by a
-// crashed taker expires like the lock itself. Returns whether to re-race the create.
-const takeOverStale = (now) => {
-    const guard = `${lockPath()}.takeover`;
-    const guardHeld = holderOf(guard);
-    if (guardHeld !== null && isCrashed(guardHeld, now))
-        unlinkQuiet(guard);
-    try {
-        writeFileSync(guard, `${process.pid} ${now}`, { flag: 'wx' });
-    }
-    catch {
-        return false; // another taker is mid-takeover; let it win
-    }
-    try {
-        const holder = holderOf(lockPath());
-        if (holder !== null && !isCrashed(holder, now))
-            return false; // fresh or a live-but-slow holder
-        unlinkQuiet(lockPath());
-        return true;
-    }
-    finally {
-        unlinkQuiet(guard);
-    }
-};
-// Acquire the single-writer update lock. The O_EXCL ('wx') create IS the mutex - concurrent runs
-// cannot both win it, unlike a check-then-write. A fresh holder (younger than the TTL) refuses;
-// a stale one (crashed run) is cleared under the takeover guard and re-raced once. `now` is
-// injectable.
-export const acquireUpdateLock = (now = Date.now()) => {
-    ensureConfigDir();
-    for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-            writeFileSync(lockPath(), `${process.pid} ${now}`, { flag: 'wx' });
-            return true;
-        }
-        catch {
-            const holder = holderOf(lockPath());
-            if (holder !== null && !isCrashed(holder, now))
-                return false;
-            if (!takeOverStale(now))
-                return false;
-        }
-    }
-    return false;
-};
-export const releaseUpdateLock = () => {
-    const path = lockPath();
-    if (existsSync(path))
-        unlinkSync(path);
-};

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>;

package/dist/observability.js

@@ -1,35 +0,0 @@
-// Telemetry for the CLI and its daemon, through @agentage/observability. A real dependency here
-// (unlike @agentage/server-memory, which must stay npx-light): `agentage` is installed once,
-// globally. It is inert until OTEL_EXPORTER_OTLP_ENDPOINT names a collector, and every line it
-// writes goes to stderr - stdout stays the machine-readable channel (`--json`, the daemon's
-// JSON-RPC wire).
-// Captured before startObservability() can overwrite it, so the daemon we spawn can tell a name the
-// user chose from the default we injected.
-const userServiceName = process.env['OTEL_SERVICE_NAME'];
-export const CLI_SERVICE = 'agentage-cli';
-export const DAEMON_SERVICE = 'agentage-daemon';
-// What OTEL_SERVICE_NAME the spawned daemon should run under: the user's, else our own default.
-export const daemonServiceName = () => userServiceName || DAEMON_SERVICE;
-// Guarded even though the kit is a dependency: a half-installed global must degrade to a working
-// CLI, never to a stack trace on every command.
-export const startObservability = async (service) => {
-    // The kit (1.0.0) announces an enabled tracer with one console.log, which would land in a
-    // `--json` payload or on the daemon's JSON-RPC wire. Divert stdout to stderr while it boots; drop
-    // this once the kit writes that line to stderr itself.
-    const stdoutWrite = process.stdout.write;
-    process.stdout.write = process.stderr.write.bind(process.stderr);
-    try {
-        if (!process.env['OTEL_SERVICE_NAME'])
-            process.env['OTEL_SERVICE_NAME'] = service;
-        await import('@agentage/observability/bootstrap');
-    }
-    catch (err) {
-        if (process.env['AGENTAGE_DEBUG']) {
-            const reason = err instanceof Error ? err.message : String(err);
-            console.error(`[agentage] observability off: ${reason}`); // stderr: never corrupt stdout
-        }
-    }
-    finally {
-        process.stdout.write = stdoutWrite;
-    }
-};

package/dist/sync/discover/watcher.d.ts

@@ -1,26 +0,0 @@
-import { type DiscoverCandidate, type VaultsConfig } from '@agentage/memory-core';
-export interface DiscoverStatus {
-    roots: string[];
-}
-interface Watcher {
-    close(): void;
-}
-export interface DiscoverWatcherDeps {
-    getConfig?: () => VaultsConfig;
-    mutate?: (fn: (config: VaultsConfig) => VaultsConfig | null | void) => Promise<VaultsConfig>;
-    scan?: (config: VaultsConfig) => DiscoverCandidate[];
-    provision?: (name: string) => Promise<unknown>;
-    isDirectory?: (path: string) => boolean;
-    watch?: (dir: string, onChange: () => void) => Watcher;
-    debounceMs?: number;
-    pollMs?: number;
-    log?: (msg: string) => void;
-}
-export interface DiscoverWatcher {
-    reschedule(): void;
-    scanNow(): Promise<DiscoverCandidate[]>;
-    status(): DiscoverStatus;
-    stop(): void;
-}
-export declare const createDiscoverWatcher: (deps?: DiscoverWatcherDeps) => DiscoverWatcher;
-export {};

package/dist/sync/discover/watcher.js

@@ -1,159 +0,0 @@
-import { statSync, watch as fsWatch } from 'node:fs';
-import { expandPath, scanDiscoverRoots, } from '@agentage/memory-core';
-import { defaultProvisionDeps, provisionAccountVault } from '../../lib/auth/provision.js';
-import { addVault } from '../../lib/vault/vault-registry.js';
-import { loadVaultsConfig, mutateVaultsConfig } from '../../lib/vault/vaults.js';
-const msgOf = (err) => (err instanceof Error ? err.message : String(err));
-// Floors: a 0/near-0 poll interval would busy-loop the daemon; a 0 debounce defeats coalescing.
-const POLL_FLOOR_MS = 1000;
-const DEBOUNCE_FLOOR_MS = 50;
-const isDir = (path) => {
-    try {
-        return statSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-};
-const defaultWatch = (dir, onChange) => {
-    const w = fsWatch(dir, { persistent: false }, () => onChange());
-    w.on('error', () => { }); // an unreliable fs: the poll fallback still covers the root
-    return w;
-};
-export const createDiscoverWatcher = (deps = {}) => {
-    const getConfig = deps.getConfig ?? (() => loadVaultsConfig().config);
-    const mutate = deps.mutate ?? mutateVaultsConfig;
-    const scan = deps.scan ?? scanDiscoverRoots;
-    const provision = deps.provision ?? ((name) => provisionAccountVault(name, defaultProvisionDeps()));
-    const isDirectory = deps.isDirectory ?? isDir;
-    const watch = deps.watch ?? defaultWatch;
-    const debounceMs = Math.max(DEBOUNCE_FLOOR_MS, deps.debounceMs ?? 500);
-    const pollMs = Math.max(POLL_FLOOR_MS, deps.pollMs ?? 60_000);
-    const log = deps.log ?? (() => { });
-    const watchers = [];
-    let debounceTimer;
-    let pollTimer;
-    let scanning = false;
-    let queued = false;
-    const roots = (config) => (config.discover ?? []).map((r) => expandPath(r.path));
-    const runScan = async () => {
-        let candidates;
-        try {
-            candidates = scan(getConfig());
-        }
-        catch (err) {
-            log(`scan failed: ${msgOf(err)}`);
-            return [];
-        }
-        if (candidates.length === 0)
-            return [];
-        // Fold the candidates onto the FRESH on-disk config inside the cross-process lock (issue #231):
-        // re-read, register any still-absent-and-present folder, save - so a concurrent `vault add` (or
-        // a second daemon) is never clobbered. Return null when nothing changed so the file is left
-        // untouched (a redundant write would loop the daemon's own config watcher).
-        let added = [];
-        try {
-            await mutate((fresh) => {
-                added = [];
-                let next = fresh;
-                for (const c of candidates) {
-                    if (next.vaults?.[c.name])
-                        continue; // registered by a concurrent writer
-                    if (!c.entry.path || !isDirectory(c.entry.path))
-                        continue; // vanished before we wrote it
-                    try {
-                        next = addVault(next, c.name, c.entry);
-                        added.push(c);
-                    }
-                    catch (err) {
-                        log(`register '${c.name}' failed: ${msgOf(err)}`);
-                    }
-                }
-                return added.length > 0 ? next : null;
-            });
-        }
-        catch (err) {
-            log(`save failed: ${msgOf(err)}`);
-            return [];
-        }
-        if (added.length === 0)
-            return [];
-        for (const c of added) {
-            log(`discovered account vault '${c.name}' -> ${c.entry.path}`);
-            void provision(c.name).catch(() => { }); // never fatal: the next scan re-provisions
-        }
-        return added;
-    };
-    // Serialise scans against themselves; a change during an in-flight scan queues one more pass.
-    const scanNow = async () => {
-        if (scanning) {
-            queued = true;
-            return [];
-        }
-        scanning = true;
-        try {
-            return await runScan();
-        }
-        finally {
-            scanning = false;
-            if (queued) {
-                queued = false;
-                void scanNow();
-            }
-        }
-    };
-    const debounced = () => {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
-            debounceTimer = undefined;
-            void scanNow();
-        }, debounceMs);
-        debounceTimer.unref?.();
-    };
-    const closeWatchers = () => {
-        for (const w of watchers.splice(0)) {
-            try {
-                w.close();
-            }
-            catch {
-                // already closed
-            }
-        }
-    };
-    const reschedule = () => {
-        closeWatchers();
-        const config = getConfig();
-        for (const dir of roots(config).filter(isDirectory)) {
-            try {
-                watchers.push(watch(dir, debounced));
-            }
-            catch (err) {
-                log(`watch ${dir} failed: ${msgOf(err)}`);
-            }
-        }
-        // The poll fallback runs while any root is configured (even one not yet a directory), so a root
-        // created after boot is still picked up where fs.watch is unreliable.
-        if (roots(config).length > 0 && !pollTimer) {
-            pollTimer = setInterval(() => void scanNow(), pollMs);
-            pollTimer.unref?.();
-        }
-        else if (roots(config).length === 0 && pollTimer) {
-            clearInterval(pollTimer);
-            pollTimer = undefined;
-        }
-        void scanNow(); // initial scan on boot, and a re-scan whenever the config changes
-    };
-    const stop = () => {
-        closeWatchers();
-        if (debounceTimer) {
-            clearTimeout(debounceTimer);
-            debounceTimer = undefined;
-        }
-        if (pollTimer) {
-            clearInterval(pollTimer);
-            pollTimer = undefined;
-        }
-    };
-    return { reschedule, scanNow, status: () => ({ roots: roots(getConfig()) }), stop };
-};

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

@@ -1 +0,0 @@
-export declare const conflictName: (path: string, exists: (candidate: string) => boolean) => string;

package/dist/sync/git/conflict.js

@@ -1,16 +0,0 @@
-// The name for the file that preserves the remote side of a conflict: `x.md` -> `x.conflict.md`.
-// An existing name is never clobbered - a numeric suffix is added instead (`x.conflict-1.md`).
-export const conflictName = (path, exists) => {
-    const slash = path.lastIndexOf('/');
-    const dot = path.lastIndexOf('.');
-    const hasExt = dot > slash + 1; // a dot inside the basename, not a leading dot
-    const stem = hasExt ? path.slice(0, dot) : path;
-    const ext = hasExt ? path.slice(dot) : '';
-    const base = `${stem}.conflict${ext}`;
-    if (!exists(base))
-        return base;
-    let i = 1;
-    while (exists(`${stem}.conflict-${i}${ext}`))
-        i += 1;
-    return `${stem}.conflict-${i}${ext}`;
-};

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

@@ -1,18 +0,0 @@
-import { type GitErrorKind, type SyncGit } from './git-exec.js';
-import { type SyncTarget } from './planner.js';
-export interface SyncResult {
-    vault: string;
-    remote: string;
-    ok: boolean;
-    committed: boolean;
-    pushed: boolean;
-    conflicts: string[];
-    skipped?: 'lock' | 'busy' | 'invalid-remote';
-    reason?: GitErrorKind;
-    error?: string;
-}
-export interface CycleDeps {
-    git?: SyncGit;
-    now?: () => string;
-}
-export declare const runSyncCycle: (target: SyncTarget, deps?: CycleDeps) => Promise<SyncResult>;