@agentage/cli 0.35.0 → 0.38.0

package/README.md

@@ -1,122 +1,92 @@
 # @agentage/cli
 
-[![CI](https://github.com/agentage/cli/actions/workflows/ci.yml/badge.svg)](https://github.com/agentage/cli/actions/workflows/ci.yml)
-[![npm version](https://badge.fury.io/js/%40agentage%2Fcli.svg)](https://badge.fury.io/js/%40agentage%2Fcli)
+![Connect this machine to agentage from the terminal](https://github.com/agentage/cli/raw/master/docs/banner.svg)
 
-Give every AI on your machine one shared memory - plain markdown you own, synced across your devices.
+Connect this machine to your [agentage](https://agentage.io) account from the terminal. One
+command signs you in through your browser, and from then on the machine is known to your account.
 
-Claude, Cursor, and your other AI tools each keep their own separate memory today. This
-CLI gives them a single shared one. It lives on your disk as ordinary markdown files
-you can open, edit, and back up like any other folder. Your AI tools read and write
-those same files, so they all remember the same things. Connect a free account and your
-memory follows you to every device - and nothing is locked in, because the files are
-always just markdown you can export.
+## What is this?
 
-## How it fits together
+agentage gives your AI tools a shared, account-backed home. Every machine you use needs to be
+connected to that account once: this package does that connection. It keeps your sign-in on
+the machine (OAuth 2.1 with PKCE, nothing typed into the terminal), tells you whether the
+machine is connected, and keeps itself up to date.
 
-![Architecture](https://github.com/agentage/cli/raw/master/docs/architecture.svg)
+It is intentionally **small**: sign-in, status and update. Everything else arrives as plugins
+that the CLI installs for you.
 
-## Quickstart
+## Get started
 
-Three steps from nothing to a shared memory your AI can use.
-
-**1. Install it.** Needs Node.js 22 or newer.
+Needs Node.js 22 or newer.
 
 ```bash
 npm install -g @agentage/cli
+agentage setup
 ```
 
-**2. Create a memory.** This makes a plain folder of markdown files at `~/vaults/notes`.
-No sign-in needed.
-
-```bash
-agentage vault add notes --local
-```
-
-**3. Connect your AI.** This example wires up Claude Code over MCP, the open protocol AI
-tools use to call tools. Any AI tool that speaks MCP connects the same way.
+`setup` opens your browser, you sign in, and the session is stored in `~/.agentage`. Then:
 
 ```bash
-claude mcp add --transport http agentage http://127.0.0.1:4243/mcp
+agentage status
 ```
 
-That's it. Ask your AI to remember something, and it lands in your `~/vaults/notes`
-folder as a markdown file you own.
-
-## What your AI can do
-
-Once connected, your AI can:
-
-- Remember things you tell it, saved as a note.
-- Find them again later by keyword.
-- Read back a specific note in full.
-- Update a note in place, or add to it.
-- Browse the folders your notes are organized into.
-- Remove a note it no longer needs (deletes are recoverable).
-
-You can do all of this from the terminal too - run `agentage memory --help` to see how.
-
-## Sync across devices
-
-Want the same memory on your laptop, desktop, and phone? Connect a free account:
+### On a server or in CI (no browser)
 
 ```bash
-agentage setup
+agentage setup --no-browser        # prints the sign-in URL to open elsewhere
+AGENTAGE_TOKEN=aga_... agentage status   # or use a personal access token
 ```
 
-This opens your browser for a one-time sign-in - no API key to copy or passwords in the
-terminal. After that, sync runs quietly in the background and the same memory follows
-you everywhere. Your files always stay yours: they remain plain markdown on your disk,
-and you can export them any time.
-
-Prefer to host it yourself? You can point a memory at your own git remote instead with
-`agentage vault add <name> --git <remote>` - see [`docs/reference.md`](docs/reference.md)
-for details.
+### Then
 
-## Token auth (CI / headless)
+- `agentage status --json` in scripts to check the machine is connected.
+- `agentage update` whenever a newer version is published; `status` tells you when.
 
-For CI or non-interactive machines, skip the browser sign-in and authenticate with a
-personal access token. Mint one in the dashboard under **Settings -> API tokens**
-(scopes `memory:read` / `memory:write`), then set it in the environment:
+## Commands
 
-```bash
-export AGENTAGE_TOKEN=aga_...
-agentage status
-```
+| Command                       | What it does                                                            |
+| ----------------------------- | ----------------------------------------------------------------------- |
+| `agentage setup`              | Sign in through your browser, then show status                          |
+| `agentage setup --no-browser` | Print the sign-in URL instead of opening a browser                      |
+| `agentage setup --reauth`     | Force a fresh sign-in                                                   |
+| `agentage setup --disconnect` | Sign out and remove local credentials                                   |
+| `agentage status`             | Version, update, target, sign-in state, endpoint (`--json` for scripts) |
+| `agentage update`             | Install the latest published version (`--check` only reports)           |
 
-The token is used as the bearer for memory (MCP) calls; `--token aga_...` works per command
-too. Account-channel provisioning still needs an interactive `agentage setup` session.
+Flags, exit codes and token auth are in [`docs/reference.md`](docs/reference.md).
 
-## Going deeper
+## How it works
 
-- [`docs/architecture.md`](docs/architecture.md) - how the CLI, the local helper, your
-  files, and sync fit together.
-- [`docs/reference.md`](docs/reference.md) - every command and flag, the full sync
-  options, MCP details, and environment variables.
+This is the **terminal client for an agentage account**. `setup` registers a one-off OAuth
+client, opens the authorization page in your browser and waits on a localhost callback; the
+tokens land in `~/.agentage/auth.json` with owner-only permissions and are refreshed
+automatically. `status` validates the session against the account's introspection endpoint
+and reports version, update, target host and connectivity. Nothing runs in the background and
+nothing is installed beyond this package.
 
-## Telemetry (off by default)
+## Configuration
 
-Nothing leaves your machine unless you ask for it. The CLI and its local helper ship with
-`@agentage/observability`, which stays inert until `OTEL_EXPORTER_OTLP_ENDPOINT` points at a
-collector you choose - then the CLI reports as `agentage-cli` and the helper as `agentage-daemon`
-(override with `OTEL_SERVICE_NAME`). Every line it writes goes to stderr, so `--json` output and the
-helper's MCP wire stay clean.
+| Env                   | Default       | Purpose                                            |
+| --------------------- | ------------- | -------------------------------------------------- |
+| `AGENTAGE_SITE_FQDN`  | `agentage.io` | Target host                                        |
+| `AGENTAGE_CONFIG_DIR` | `~/.agentage` | Config and credentials directory                   |
+| `AGENTAGE_TOKEN`      | -             | Personal access token for CI and headless machines |
+| `NO_COLOR`            | -             | Disable colored output                             |
 
-## Development
+## Develop
 
 ```bash
 npm ci
-npm run verify        # type-check + lint + format:check + unit tests + build
+npm run verify
+npm run build && npm run test:e2e -- --grep @offline
 ```
 
-End-to-end tests (Playwright) run in tiers - the offline tiers need no network or
-account. See [`docs/reference.md`](docs/reference.md) for more.
+## Release
 
-```bash
-npm run build && npm run test:e2e                      # all e2e tiers
-npm run build && npm run test:e2e -- --grep @offline   # offline tiers only
-```
+Releases publish to npm via GitHub Actions when a `chore(release): X.Y.Z` commit that touches
+`package.json` lands on `master` (the squash-merge subject of a release PR). The workflow skips
+any version already on npm.
 
 ## License
 
-MIT
+MIT - see [LICENSE](./LICENSE).

package/dist/cli.js

@@ -1,15 +1,10 @@
 #!/usr/bin/env node
-// The bin is a loader, nothing else. @agentage/observability instruments node:http, fetch and MCP
-// tool registration through module hooks, and a hook only sees a module imported after it is
-// registered - so the bootstrap runs first and the program is imported dynamically behind it.
 // Dependency-free guard so the message survives even if deps fail to parse on old Node.
 const nodeMajor = Number(process.versions.node.split('.')[0]);
 if (nodeMajor < 22) {
     process.stderr.write(`agentage requires Node.js >= 22 (you have v${process.versions.node})\n`);
     process.exit(1);
 }
-const { CLI_SERVICE, startObservability } = await import('./observability.js');
-await startObservability(CLI_SERVICE);
 const { run } = await import('./program.js');
 await run();
 export {};

package/dist/commands/auth/setup.d.ts

@@ -1,6 +1,5 @@
 import { type Command } from 'commander';
 import { startCallbackServer } from '../../lib/auth/callback-server.js';
-import { ensureDaemon } from '../../lib/daemon/daemon-client.js';
 import { introspectToken } from '../../lib/auth/api.js';
 import { exchangeCode, registerClient, revokeToken } from '../../lib/auth/oauth.js';
 export interface SetupOptions {
@@ -15,7 +14,6 @@ export interface SetupDeps {
     startServer: typeof startCallbackServer;
     openBrowser: (url: string) => Promise<void>;
     printStatus: () => Promise<void>;
-    ensureDaemon: typeof ensureDaemon;
     introspect: typeof introspectToken;
 }
 export declare const runSetup: (opts: SetupOptions, deps?: SetupDeps) => Promise<void>;

package/dist/commands/auth/setup.js

@@ -1,13 +1,10 @@
 import chalk from 'chalk';
 import { startCallbackServer } from '../../lib/auth/callback-server.js';
-import { ensureDaemon } from '../../lib/daemon/daemon-client.js';
-import { daemonDisabled } from '../../lib/daemon/daemon-pref.js';
 import { deleteAuth, ensureConfigDir, mutateAuth, readAuth, } from '../../lib/fs/config.js';
 import { AuthRequiredError, introspectToken } from '../../lib/auth/api.js';
 import { detectEnvMismatch } from '../../lib/auth/env-match.js';
 import { buildAuthorizeUrl, exchangeCode, pkcePair, randomState, registerClient, revokeToken, } from '../../lib/auth/oauth.js';
 import { links, siteFqdn } from '../../lib/net/origins.js';
-import { ensureVaultsConfig } from '../../lib/vault/vaults.js';
 import { runStatus } from '../status/status.js';
 const defaultDeps = {
     register: registerClient,
@@ -19,7 +16,6 @@ const defaultDeps = {
         await open(url);
     },
     printStatus: () => runStatus({}),
-    ensureDaemon,
     introspect: introspectToken,
 };
 const toAuthState = (fqdn, clientId, tokens) => ({
@@ -31,18 +27,6 @@ const toAuthState = (fqdn, clientId, tokens) => ({
         expiresAt: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,
     },
 });
-// After sign-in, bring the daemon up so account sync starts immediately; ensureDaemon reuses a
-// live daemon and starts a stopped one (idempotent). Honor the --no-daemon / AGENTAGE_NO_DAEMON
-// disable switches.
-const startDaemon = async (deps) => {
-    if (daemonDisabled()) {
-        console.log('Daemon disabled - account sync will run in-process on demand.');
-        return;
-    }
-    const client = await deps.ensureDaemon();
-    const fail = 'Could not start the daemon - run: agentage daemon start';
-    console.log(client ? 'Daemon running.' : fail);
-};
 const disconnect = async (deps) => {
     const auth = readAuth();
     if (!auth) {
@@ -91,7 +75,6 @@ export const runSetup = async (opts, deps = defaultDeps) => {
     const fqdn = siteFqdn();
     const target = links(fqdn);
     ensureConfigDir();
-    ensureVaultsConfig();
     const { verifier, challenge } = pkcePair();
     const state = randomState();
     const server = await deps.startServer(state);
@@ -120,7 +103,6 @@ export const runSetup = async (opts, deps = defaultDeps) => {
         });
         await mutateAuth(() => toAuthState(fqdn, clientId, tokens));
         console.log(chalk.green('\nSigned in.\n'));
-        await startDaemon(deps);
         await deps.printStatus();
     }
     finally {

package/dist/commands/status/status.js

@@ -1,9 +1,7 @@
 import chalk from 'chalk';
 import { resolveAuth } from '../../lib/auth/credentials.js';
 import { siteFqdn } from '../../lib/net/origins.js';
-import { formatUptime } from '../../lib/status/format.js';
-import { gatherStatus, } from '../../lib/status/status-info.js';
-import { vaultLines } from '../../lib/status/vaults-format.js';
+import { gatherStatus } from '../../lib/status/status-info.js';
 import { INSTALL_HINT } from '../../lib/update/update-check.js';
 const mark = (good) => (good ? chalk.green('✓') : chalk.red('✗'));
 const row = (label, value) => {
@@ -36,24 +34,6 @@ const updateLine = (update) => {
             return chalk.dim('- update check unavailable');
     }
 };
-const daemonLine = (d, cliVersion) => {
-    if (!d.running)
-        return `${mark(false)} stopped - run: agentage daemon start`;
-    const up = d.uptimeSeconds !== undefined ? `, up ${formatUptime(d.uptimeSeconds)}` : '';
-    const stale = d.daemonVersion && d.daemonVersion !== cliVersion
-        ? chalk.yellow(` (version ${d.daemonVersion} != cli ${cliVersion})`)
-        : '';
-    return `${mark(true)} running (pid ${d.pid ?? '?'}, port ${d.port}${up})${stale}`;
-};
-const mcpLine = (d) => d.mcp ? `${mark(true)} serving at http://127.0.0.1:${d.port}/mcp` : `${mark(false)} off`;
-// Daemon rows honor version-mismatch inline (appended to the daemon row) and print mcp only when
-// running; the per-vault sync breakdown now lives in its own `vaults` block (printStatus).
-const printDaemon = (d, cliVersion) => {
-    row('daemon', daemonLine(d, cliVersion));
-    if (!d.running)
-        return;
-    row('mcp', mcpLine(d));
-};
 export const printStatus = (report) => {
     row('version', report.version);
     row('update', updateLine(report.update));
@@ -63,10 +43,6 @@ export const printStatus = (report) => {
     row('auth', authLine(report.auth));
     row('endpoint', `${mark(report.endpoint.reachable)} ${report.endpoint.url} ` +
         (report.endpoint.reachable ? 'reachable' : 'unreachable'));
-    if (report.daemon)
-        printDaemon(report.daemon, report.version);
-    for (const line of vaultLines(report.vaults))
-        console.log(line);
     if (report.update.message)
         console.log(chalk.yellow(`\n${report.update.message}`));
 };

package/dist/commands/update/update.d.ts

@@ -1,17 +1,8 @@
 import { type Command } from 'commander';
-import { type SpawnOutcome } from '../../lib/daemon/daemon-client.js';
 import { type UpdateInfo } from '../../lib/update/update-check.js';
-export type RestartOutcome = 'restarted' | 'failed' | 'not-running';
-export interface RestartDeps {
-    running?: () => boolean;
-    stop?: () => Promise<boolean>;
-    start?: (port: number) => Promise<SpawnOutcome>;
-}
-export declare const restartDaemonIfRunning: (deps?: RestartDeps) => Promise<RestartOutcome>;
 export interface UpdateDeps {
     check: (installed: string) => Promise<UpdateInfo>;
     install: () => Promise<void>;
-    restartDaemon: () => Promise<RestartOutcome>;
     acquireLock: () => boolean;
     releaseLock: () => void;
     log: (msg: string) => void;

package/dist/commands/update/update.js

@@ -1,29 +1,15 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import chalk from 'chalk';
-import { isDaemonRunning, resolvePort, stopDaemonAndWait } from '../../daemon/lifecycle.js';
-import { spawnDaemon } from '../../lib/daemon/daemon-client.js';
 import { checkForUpdate, INSTALL_HINT } from '../../lib/update/update-check.js';
 import { acquireUpdateLock, releaseUpdateLock } from '../../lib/update/update-lock.js';
 import { VERSION } from '../../utils/version.js';
 const pexec = promisify(execFile);
-// Restart a running daemon so it picks up the freshly installed binary; a stopped daemon is left
-// stopped. Waits for the old process to exit (port free) before spawning, and reports honestly
-// when the new daemon did not come up.
-export const restartDaemonIfRunning = async (deps = {}) => {
-    const running = deps.running ?? isDaemonRunning;
-    if (!running())
-        return 'not-running';
-    await (deps.stop ?? stopDaemonAndWait)();
-    const up = await (deps.start ?? spawnDaemon)(resolvePort());
-    return up.ok ? 'restarted' : 'failed';
-};
 const defaultDeps = {
     check: checkForUpdate,
     install: async () => {
         await pexec('npm', ['install', '-g', '@agentage/cli@latest']);
     },
-    restartDaemon: () => restartDaemonIfRunning(),
     acquireLock: () => acquireUpdateLock(),
     releaseLock: releaseUpdateLock,
     log: (msg) => console.log(msg),
@@ -41,16 +27,10 @@ const describe = (info) => {
             return chalk.yellow(`Couldn't reach the registry - try again later. ${INSTALL_HINT}`);
     }
 };
-// Install, then restart a running daemon so its in-process engine runs the new version.
 const install = async (deps) => {
     deps.log('Installing the latest @agentage/cli...');
     await deps.install();
     deps.log(chalk.green('Updated. Run `agentage status` to confirm.'));
-    const outcome = await deps.restartDaemon();
-    if (outcome === 'restarted')
-        deps.log(chalk.green('Restarted the daemon on the new version.'));
-    if (outcome === 'failed')
-        deps.log(chalk.yellow('Daemon did not restart cleanly - run `agentage daemon start`.'));
 };
 // --check reports the verdict and never installs. Otherwise, install only when the registry says
 // we're behind (available/unsupported), guarded by a single-writer lock; current/unreachable just

package/dist/core/flag.d.ts

@@ -0,0 +1 @@
+export declare const pluginsEnabled: () => boolean;

package/dist/core/flag.js

@@ -0,0 +1 @@
+export const pluginsEnabled = () => process.env['AGENTAGE_PLUGINS'] === '1';

package/dist/lib/auth/api.js

@@ -4,7 +4,7 @@ import { requestHeaders } from '../net/user-agent.js';
 import { AuthRequiredError, isTerminalRefresh, TransientAuthError } from './auth-errors.js';
 export { AuthRequiredError, TransientAuthError } from './auth-errors.js';
 // Every authed call is CLI-originated; identify the caller alongside the bearer.
-const cliHeaders = () => requestHeaders({ component: 'cli' });
+const cliHeaders = () => requestHeaders();
 // Refresh the stored token in place. On success mutates auth + persists and returns. On failure it
 // throws: AuthRequiredError when the grant is dead (401/invalid_grant/invalid_client), else
 // TransientAuthError (429/5xx/network/timeout) - a blip that must not be read as a dead session.

package/dist/lib/auth/oauth.js

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { requestHeaders } from '../net/user-agent.js';
 // OAuth register/token/revoke are all CLI-originated; identify the caller on each.
-const cliHeaders = () => requestHeaders({ component: 'cli' });
+const cliHeaders = () => requestHeaders();
 const REGISTER_PATH = '/api/auth/mcp/register';
 const AUTHORIZE_PATH = '/api/auth/mcp/authorize';
 const TOKEN_PATH = '/api/auth/mcp/token';

package/dist/lib/net/origins.d.ts

@@ -3,8 +3,6 @@ export interface Links {
     site: string;
     api: string;
     auth: string;
-    mcp: string;
-    sync: string;
 }
 export declare const normalizeFqdn: (raw?: string) => string;
 export declare const siteFqdn: () => string;

package/dist/lib/net/origins.js

@@ -20,20 +20,16 @@ export const environment = (fqdn) => isLocal(fqdn) || fqdn.startsWith('dev.') ?
 export const links = (fqdn) => {
     const stub = stubOrigin(fqdn);
     if (stub)
-        return { site: stub, api: `${stub}/api`, auth: stub, mcp: `${stub}/mcp`, sync: stub };
+        return { site: stub, api: `${stub}/api`, auth: stub };
     return isLocal(fqdn)
         ? {
             site: 'http://localhost:3000',
             api: 'http://localhost:3001/api',
             auth: 'http://localhost:3010',
-            mcp: 'http://localhost:3003/mcp',
-            sync: 'http://localhost:3011',
         }
         : {
             site: `https://${fqdn}`,
             api: `https://api.${fqdn}/api`,
             auth: `https://auth.${fqdn}`,
-            mcp: `https://memory.${fqdn}/mcp`,
-            sync: `https://sync.${fqdn}`,
         };
 };

package/dist/lib/net/user-agent.d.ts

@@ -1,6 +1 @@
-export type RequestComponent = 'cli' | 'daemon';
-export interface RequestHeaderOptions {
-    component: RequestComponent;
-    daemonVersion?: string;
-}
-export declare const requestHeaders: (opts: RequestHeaderOptions) => Record<string, string>;
+export declare const requestHeaders: () => Record<string, string>;

package/dist/lib/net/user-agent.js

@@ -1,7 +1,6 @@
 import { VERSION } from '../../utils/version.js';
-// Identify the caller + versions so the server can observe which CLI + daemon connect.
-export const requestHeaders = (opts) => ({
-    'User-Agent': `agentage-${opts.component}/${VERSION}`,
+// Identify the caller and its version so the server can observe which CLI connects.
+export const requestHeaders = () => ({
+    'User-Agent': `agentage-cli/${VERSION}`,
     'X-Agentage-CLI-Version': VERSION,
-    'X-Agentage-Daemon-Version': opts.component === 'daemon' ? VERSION : (opts.daemonVersion ?? 'none'),
 });

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

@@ -2,22 +2,6 @@ import { type AuthEnvMismatch } from '../auth/env-match.js';
 import { type AuthState } from '../fs/config.js';
 import { type Env } from '../net/origins.js';
 import { type UpdateInfo } from '../update/update-check.js';
-import { type VaultStatus } from './vaults-status.js';
-export interface DaemonSyncSummary {
-    vaults: number;
-    state: 'ok' | 'error' | 'syncing';
-    lastRun?: string;
-    lastError?: string;
-}
-export interface DaemonStatus {
-    running: boolean;
-    pid?: number;
-    port: number;
-    uptimeSeconds?: number;
-    mcp?: boolean;
-    daemonVersion?: string;
-    sync?: DaemonSyncSummary;
-}
 export interface StatusReport {
     version: string;
     fqdn: string;
@@ -40,7 +24,5 @@ export interface StatusReport {
         reachable: boolean;
     };
     update: UpdateInfo;
-    daemon?: DaemonStatus;
-    vaults: VaultStatus[];
 }
 export declare const gatherStatus: (auth: AuthState | null, fqdn: string) => Promise<StatusReport>;

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

@@ -1,13 +1,10 @@
 import { AuthRequiredError, introspectToken } from '../auth/api.js';
 import { detectEnvMismatch } from '../auth/env-match.js';
-import { health, syncStatus } from '../daemon/daemon-client.js';
 import { fetchJsonUnref } from '../net/http.js';
 import { requestHeaders } from '../net/user-agent.js';
 import { environment, links } from '../net/origins.js';
 import { checkForUpdate } from '../update/update-check.js';
 import { VERSION } from '../../utils/version.js';
-import { isDaemonRunning, resolvePort } from '../../daemon/lifecycle.js';
-import { buildVaultStatuses } from './vaults-status.js';
 // node:https via fetchJsonUnref, not global fetch: undici's ref'd connect timer keeps the process
 // alive ~10s after an aborted request on a packet-drop network, stalling `status` exit.
 const checkEndpoint = async (apiUrl, headers) => {
@@ -20,40 +17,6 @@ const checkSite = async (siteUrl, headers) => {
     const res = await fetchJsonUnref(siteUrl, 3000, headers);
     return res !== null;
 };
-// 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 error = git.find((v) => v.lastError)?.lastError;
-    const running = git.some((v) => v.running);
-    const state = error ? 'error' : running ? 'syncing' : 'ok';
-    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();
-    const h = await health(port);
-    if (!h)
-        return { status: { running: isDaemonRunning(), port }, sync: null };
-    const sync = await syncStatus(port);
-    const summary = sync ? summarizeSync(sync) : undefined;
-    const status = {
-        running: true,
-        pid: h.pid,
-        port,
-        uptimeSeconds: h.uptime,
-        // Absent on a legacy daemon that predates the /mcp gate; treat undefined as serving (on).
-        mcp: h.mcp !== false,
-        daemonVersion: h.version,
-        sync: summary && summary.vaults > 0 ? summary : undefined,
-    };
-    return { status, sync };
-};
 // AuthRequiredError = truly expired (terminal). TransientAuthError (or any non-terminal) = a blip
 // while we could not re-verify: never rendered as expired, never told to run setup, exit stays 0.
 const classifyAuthError = (err) => err instanceof AuthRequiredError
@@ -70,9 +33,7 @@ const mismatchAuth = (m) => ({
 export const gatherStatus = async (auth, fqdn) => {
     const target = links(fqdn);
     const env = environment(fqdn);
-    // Probe the local daemon first (fast, 1s-capped /health) so its version can ride the probe headers.
-    const probe = await probeDaemon();
-    const headers = requestHeaders({ component: 'cli', daemonVersion: probe.status.daemonVersion });
+    const headers = requestHeaders();
     // Endpoint reachability and the (npm-registry) update check are independent - run them
     // together so `status` stays snappy.
     const [reachable, siteReachable, update] = await Promise.all([
@@ -88,8 +49,6 @@ export const gatherStatus = async (auth, fqdn) => {
         auth: { signedIn: false, note: 'not signed in - run: agentage setup' },
         endpoint: { url: target.api, reachable },
         update,
-        daemon: probe.status,
-        vaults: buildVaultStatuses(probe.sync, probe.status.running),
     };
     if (!auth)
         return report;

package/dist/plugin.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_API_VERSION = "1.0.0";

package/dist/plugin.js

@@ -0,0 +1,2 @@
+// The plugin contract is versioned apart from the CLI, so plugins pin it, not a CLI release.
+export const PLUGIN_API_VERSION = '1.0.0';

package/dist/program.js

@@ -1,25 +1,16 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
-import { registerDaemon } from './commands/daemon/daemon-cmd.js';
-import { registerMemory } from './commands/memory/memory.js';
 import { registerSetup } from './commands/auth/setup.js';
 import { registerStatus } from './commands/status/status.js';
 import { registerUpdate } from './commands/update/update.js';
-import { registerVault } from './commands/vault/vault.js';
-import { disableDaemon } from './lib/daemon/daemon-pref.js';
 import { refreshUpdateCache, updateHint } from './lib/update/update-cache.js';
 import { VERSION } from './utils/version.js';
 const program = new Command();
 program
     .name('agentage')
-    .description('The offline-first terminal client for agentage Memory')
-    .version(VERSION)
-    .option('--no-daemon', 'run memory verbs in-process instead of via the daemon');
-program.addHelpText('after', '\nNew here? Run: agentage vault add <name> --local, or agentage setup to connect an account.');
-program.hook('preAction', () => {
-    if (program.opts().daemon === false)
-        disableDaemon();
-});
+    .description('Connect this machine to agentage from the terminal')
+    .version(VERSION);
+program.addHelpText('after', '\nNew here? Run: agentage setup to connect this machine.');
 // After any command (except the update-aware ones, which report richer state themselves), print a
 // one-line hint from the cache, then kick a fire-and-forget refresh. Never awaited, never throws -
 // the command output is already done and the cache-only read keeps this instant. The hint is
@@ -37,11 +28,8 @@ program.hook('postAction', (_thisCommand, actionCommand) => {
 });
 registerSetup(program);
 registerStatus(program);
-registerVault(program);
-registerMemory(program);
-registerDaemon(program);
 registerUpdate(program);
-// Called by the bin (src/cli.ts) once the observability bootstrap has run.
+// Called by the bin (src/cli.ts).
 export const run = async () => {
     await program.parseAsync().catch((err) => {
         console.error(err instanceof Error ? err.message : String(err));