awb-agent-manager 1.0.0

package/dist/main.js

@@ -0,0 +1,670 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve, join as pathJoin } from 'node:path';
+import { AGENT_MANAGER_HOME, CONFIG_PATH, LEGACY_CONFIG_PATH, MANAGED_AGENTS_DIR, } from './lib/constants.js';
+import { loadConfig, resolveAgentId } from './lib/config.js';
+import { installCrashHandlers, log } from './lib/logging.js';
+import { acquireAgentLock, inspectLegacyAgentLock, } from './lib/agent-lockfile.js';
+import { importLegacyConfig } from './lib/legacy-import.js';
+import { isSystemdReExecPending, runSelfUpdate, UpdateChecker } from './lib/self-update.js';
+import { runSetup } from './lib/setup.js';
+import { installService, uninstallService } from './lib/service-install.js';
+import { PresenceHeartbeat } from './lib/presence-heartbeat.js';
+import { InstanceHeartbeat } from './lib/instance-heartbeat.js';
+import { EventStream } from './lib/event-stream.js';
+import { SubagentManager } from './lib/subagent-manager.js';
+import { ChatSessionManager } from './lib/chat-session-manager.js';
+import { TicketSessionManager } from './lib/ticket-session-manager.js';
+import { CircuitBreaker } from './lib/circuit-breaker.js';
+import { uploadIfNewErrors } from './lib/error-log-uploader.js';
+import { onFlushThreshold } from './lib/event-log-recorder.js';
+import { cleanupOrphanSubagents } from './lib/orphan-cleanup.js';
+import { FsBrowser } from './lib/fs-browser.js';
+import { SubagentMonitor } from './lib/subagent-monitor.js';
+import { KNOWN_ADAPTER_CLI_TYPES, createAdapter } from './lib/cli-adapters/index.js';
+import { promptComposer } from './lib/prompts.js';
+import { ManagedAgentRegistry } from './lib/managed-agents.js';
+import { ManagedAgentContextRegistry } from './lib/managed-agent-context.js';
+import { WorktreeManager, worktreeSlug } from './lib/worktree-manager.js';
+import { EnvironmentProvisioner } from './lib/environment-provisioner.js';
+import { AgentManagerCommandHandler } from './lib/agent-manager-commands.js';
+import { listManagedAgentDirs, readManagedAgentConfig, readApiKey, readAgentCredential, mcpConfigPathFor, subagentLogPathFor, cliHomeDirFor, ensureCliHomeDir, } from './lib/managed-agent-store.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function readPkgVersion() {
+    try {
+        const pkgPath = resolve(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function parseFlags(argv) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args: argv,
+            options: {
+                config: { type: 'string', short: 'c' },
+                workspace: { type: 'string', short: 'w' },
+                'dry-run': { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+                version: { type: 'boolean', short: 'v' },
+                force: { type: 'boolean', short: 'f' },
+            },
+            allowPositionals: false,
+            strict: true,
+        }));
+    }
+    catch (err) {
+        process.stderr.write(`\n  ✗ ${err?.message ?? err}\n\n`);
+        process.stderr.write(`  Run \`awb-agent-manager --help\` for usage.\n\n`);
+        process.exit(2);
+    }
+    return {
+        config: values.config,
+        workspace: values.workspace,
+        dryRun: Boolean(values['dry-run']),
+        help: Boolean(values.help),
+        version: Boolean(values.version),
+        force: Boolean(values.force),
+    };
+}
+function printHelp() {
+    process.stdout.write(`awb-agent-manager — standalone AWB subagent runner
+
+Usage:
+  awb-agent-manager                       start the manager (uses saved config)
+  awb-agent-manager setup [opts]          first-run pairing wizard
+  awb-agent-manager service install [..]  register as a background service (auto-detects host)
+  awb-agent-manager service uninstall     remove the registered service
+  awb-agent-manager mcp-host              run the host-tools MCP server over stdio
+                                          (spawned by managed agents; not for direct use)
+  awb-agent-manager [options]             start with overrides
+
+Options:
+  -c, --config <path>     Path to config.json (default: ${CONFIG_PATH})
+  -w, --workspace <id>    Override workspace_id from config
+  -f, --force             Take over the lockfile from a stale or running owner
+      --dry-run           Load config and exit without starting runtime
+  -h, --help              Show this help text
+  -v, --version           Print version
+
+Setup options (\`awb-agent-manager setup ...\`):
+      --url <url>            AWB server base URL (skip prompt)
+      --token <token>        Pairing token from AWB Admin → Agent Manager
+      --instance-id <id>     Stable id reported on heartbeats (default <hostname>-<rand>)
+      --non-interactive      Fail fast on missing fields instead of prompting
+      --force                Overwrite an existing config.json
+
+Service options (\`awb-agent-manager service install ...\`):
+      --system               Install at system scope (sudo / admin, runs at boot)
+                             Default: user scope (no admin, runs at logon)
+      --platform <p>         Force a specific service backend instead of auto-detect:
+                             auto (default) | systemd | sysvinit | synology | launchd | windows
+      --exec-path <path>     Override path to dist/main.js (default: this binary's location)
+      --dry-run              Print the unit/plist/script without writing or running registrar
+      --unit-only            Write the unit file but skip daemon-reload / load / register
+
+Platform mapping (auto):
+  linux + systemd        → ~/.config/systemd/user/ (user) | /etc/systemd/system/ (--system)
+  linux + Synology DSM   → /usr/local/etc/rc.d/awb-agent-manager.sh (always system)
+  linux without systemd  → /etc/init.d/awb-agent-manager (always system, sysvinit)
+  darwin (macOS)         → ~/Library/LaunchAgents/ (user) | /Library/LaunchDaemons/ (--system)
+  win32                  → Task Scheduler task 'awb-agent-manager' (logon | --system boot)
+
+Config search order:
+  1. --config flag
+  2. $AWB_AGENT_MANAGER_HOME/config.json
+  3. $XDG_CONFIG_HOME/awb-agent-manager/config.json (or %APPDATA% on Windows)
+  4. ~/.config/awb-agent-manager/config.json
+
+Legacy import:
+  On first run, ${LEGACY_CONFIG_PATH} is copied into the new
+  config home if no config.json is present yet. A marker file is placed in
+  the legacy directory; subsequent runs skip the import. Existing legacy
+  files are NEVER deleted — the claude-plugin stdio MCP proxy may still use
+  them.
+
+Signals:
+  SIGTERM/SIGINT  graceful drain + exit
+  SIGHUP          re-read config.json (delegation tunables hot-reload)
+  SIGUSR1         self-update: git pull + npm install + npm run build, then
+                  re-exec with --force so the new build adopts the lockfile.
+                  No-op when the manager is not running from a git checkout.
+`);
+}
+function parseSetupArgs(argv) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args: argv,
+            options: {
+                config: { type: 'string', short: 'c' },
+                url: { type: 'string' },
+                token: { type: 'string' },
+                'instance-id': { type: 'string' },
+                'non-interactive': { type: 'boolean' },
+                force: { type: 'boolean', short: 'f' },
+            },
+            allowPositionals: false,
+            strict: true,
+        }));
+    }
+    catch (err) {
+        process.stderr.write(`\n  ✗ setup: ${err?.message ?? err}\n\n`);
+        process.stderr.write(`  Run \`awb-agent-manager --help\` for setup options.\n\n`);
+        process.exit(2);
+    }
+    return {
+        configPath: values.config || undefined,
+        url: values.url || undefined,
+        token: values.token || undefined,
+        instanceId: values['instance-id'] || undefined,
+        nonInteractive: Boolean(values['non-interactive']) || !process.stdin.isTTY,
+        force: Boolean(values.force),
+    };
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === 'mcp-host') {
+        try {
+            const { runHostMcpServerOverStdio } = await import('./lib/host-mcp/server.js');
+            await runHostMcpServerOverStdio();
+            process.exit(0);
+        }
+        catch (err) {
+            process.stderr.write(`\n  ✗ mcp-host failed: ${err?.stack ?? err?.message ?? err}\n\n`);
+            process.exit(1);
+        }
+    }
+    if (argv[0] === 'setup') {
+        try {
+            await runSetup(parseSetupArgs(argv.slice(1)));
+            process.exit(0);
+        }
+        catch (err) {
+            process.stderr.write(`\n  ✗ setup failed: ${err?.message ?? err}\n\n`);
+            process.exit(1);
+        }
+    }
+    if (argv[0] === 'service') {
+        const sub = argv[1] || '';
+        if (sub !== 'install' && sub !== 'uninstall') {
+            process.stderr.write(`\n  ✗ service: unknown subcommand '${sub}' (expected: install | uninstall)\n\n` +
+                `  Usage: awb-agent-manager service <install|uninstall> [--system] [--platform <p>] [--exec-path <p>] [--dry-run] [--unit-only]\n\n`);
+            process.exit(2);
+        }
+        let serviceValues;
+        try {
+            ({ values: serviceValues } = parseArgs({
+                args: argv.slice(2),
+                options: {
+                    system: { type: 'boolean' },
+                    'dry-run': { type: 'boolean' },
+                    'unit-only': { type: 'boolean' },
+                    'exec-path': { type: 'string' },
+                    platform: { type: 'string' },
+                },
+                allowPositionals: false,
+                strict: true,
+            }));
+        }
+        catch (err) {
+            process.stderr.write(`\n  ✗ service ${sub}: ${err?.message ?? err}\n\n`);
+            process.exit(2);
+        }
+        const isSystem = Boolean(serviceValues.system);
+        const dryRun = Boolean(serviceValues['dry-run']);
+        const unitOnly = Boolean(serviceValues['unit-only']);
+        const execPath = serviceValues['exec-path'];
+        const platformRaw = serviceValues.platform;
+        const validPlatforms = ['auto', 'systemd', 'sysvinit', 'synology', 'launchd', 'windows'];
+        if (platformRaw && !validPlatforms.includes(platformRaw)) {
+            process.stderr.write(`\n  ✗ service ${sub}: invalid --platform '${platformRaw}' ` +
+                `(expected: ${validPlatforms.join(' | ')})\n\n`);
+            process.exit(2);
+        }
+        const platform = (platformRaw || 'auto');
+        try {
+            if (sub === 'install') {
+                await installService({ system: isSystem, execPath, dryRun, unitOnly, platform });
+            }
+            else {
+                await uninstallService({ system: isSystem, platform });
+            }
+            process.exit(0);
+        }
+        catch (err) {
+            process.stderr.write(`\n  ✗ service ${sub} failed: ${err?.message ?? err}\n\n`);
+            process.exit(1);
+        }
+    }
+    const flags = parseFlags(argv);
+    if (flags.help) {
+        printHelp();
+        return;
+    }
+    if (flags.version) {
+        process.stdout.write(`${readPkgVersion()}\n`);
+        return;
+    }
+    installCrashHandlers();
+    const version = readPkgVersion();
+    process.stdout.write(`awb-agent-manager v${version}\n`);
+    process.stdout.write(`  home:        ${AGENT_MANAGER_HOME}\n`);
+    if (!flags.config) {
+        const importResult = importLegacyConfig();
+        if (importResult.imported) {
+            process.stdout.write(`  imported:    ${importResult.source.config} -> ${importResult.target.config}\n`);
+        }
+    }
+    const configPath = flags.config ?? CONFIG_PATH;
+    let config = loadConfig(configPath);
+    if (!config) {
+        process.stdout.write(`  config:      not found at ${configPath}\n`);
+        if (existsSync(LEGACY_CONFIG_PATH)) {
+            process.stdout.write(`  hint:        legacy plugin config exists at ${LEGACY_CONFIG_PATH} ` +
+                `but a previous import already ran. Copy it to ${configPath} manually if you want to re-import.\n`);
+        }
+        else {
+            process.stdout.write(`\n  No config yet. Run the pairing wizard to set one up:\n\n` +
+                `      awb-agent-manager setup\n\n` +
+                `  Or non-interactively (CI / Ansible):\n\n` +
+                `      awb-agent-manager setup --url <awb-url> --token <pairing-token>\n\n` +
+                `  The token comes from AWB Admin → Agent Manager → "Pair manager…".\n`);
+        }
+        if (flags.dryRun) {
+            log('--dry-run: exiting after config load (config=missing)');
+            return;
+        }
+        log('No config — exiting. Run `awb-agent-manager setup` first.');
+        process.exit(1);
+    }
+    if (flags.workspace) {
+        config.workspace_id = flags.workspace;
+    }
+    process.stdout.write(`  config:      ${configPath}\n`);
+    process.stdout.write(`  url:         ${config.url}\n`);
+    process.stdout.write(`  workspace:   ${config.workspace_id ?? '(none)'}\n`);
+    if (flags.dryRun) {
+        log('--dry-run: exiting after config load (config=loaded)');
+        return;
+    }
+    await runRuntime(config, version, flags, argv);
+}
+async function runRuntime(config, version, flags, argv) {
+    void argv;
+    const legacyLock = inspectLegacyAgentLock();
+    if (legacyLock.alive && legacyLock.pid) {
+        if (flags.force) {
+            log(`[legacy-lock] --force: ignoring live plugin daemon at pid=${legacyLock.pid} ` +
+                `(role=${legacyLock.role || '?'}, version=${legacyLock.version || '?'}). ` +
+                `Stop it manually if you see double-processed events.`);
+        }
+        else {
+            log(`[legacy-lock] claude-plugin daemon is still running ` +
+                `(pid=${legacyLock.pid}, role=${legacyLock.role || '?'}, ` +
+                `version=${legacyLock.version || '?'}, started_at=${legacyLock.started_at || '?'}). ` +
+                `Stop it before launching agent-manager, or pass --force to start anyway.`);
+            process.exit(3);
+        }
+    }
+    else if (legacyLock.present) {
+        log(`[legacy-lock] found stale lockfile at ${legacyLock.path} — ignoring.`);
+    }
+    let lock;
+    try {
+        lock = acquireAgentLock({ role: 'manager', version, force: flags.force });
+    }
+    catch (err) {
+        if (err?.code === 'EAGENTLOCKED') {
+            log(`agent-manager: ${err.message}`);
+            process.exit(2);
+        }
+        throw err;
+    }
+    log(`agent-manager starting (server=${config.url} version=${version})`);
+    log(`Delegation: maxConcurrent=${config.delegation.maxConcurrent} ttl=${config.delegation.ttlMinutes}min idle=${config.delegation.idleMinutes}min cliBin=${config.delegation.claudeBin}`);
+    const agentIdReady = resolveAgentId(config).then((id) => {
+        if (id)
+            log(`Agent identity: ${id.slice(0, 8)}…`);
+        else
+            log('Agent identity: not resolved — presence + error-log upload disabled until pairing writes agent.json');
+        return id;
+    });
+    const presenceHeartbeat = { _real: null };
+    const kickPresencePing = () => {
+        presenceHeartbeat._real?.pingNow().catch(() => { });
+    };
+    const instanceHeartbeat = { _real: null };
+    const updateChecker = new UpdateChecker({ log });
+    updateChecker.start();
+    cleanupOrphanSubagents()
+        .then((r) => {
+        if (r.scanned > 0)
+            log(`Orphan subagent cleanup: scanned=${r.scanned} reaped=${r.reaped} skipped=${r.skipped ?? 0}`);
+    })
+        .catch((err) => log(`Orphan subagent cleanup failed: ${err?.message ?? err}`));
+    const circuitBreaker = new CircuitBreaker();
+    const subagentManager = new SubagentManager(config, circuitBreaker);
+    subagentManager.init().catch((err) => log(`SubagentManager init failed: ${err?.message ?? err}`));
+    const managedAgents = new ManagedAgentRegistry();
+    const managedAgentContexts = new ManagedAgentContextRegistry();
+    const worktreeManager = new WorktreeManager({
+        enabled: config?.delegation?.worktreeIsolation !== false,
+    });
+    const environmentProvisioner = new EnvironmentProvisioner();
+    const chatSessionManager = new ChatSessionManager(config);
+    const ticketSessionManager = new TicketSessionManager(config, circuitBreaker);
+    let eventStreamRef = null;
+    const commandHandler = new AgentManagerCommandHandler(config, {
+        registry: managedAgents,
+        contextRegistry: managedAgentContexts,
+        chatSessionManager,
+        ticketSessionManager,
+        subagentManager,
+        circuitBreaker,
+        getInstanceId: () => instanceHeartbeat._real?.instanceId ?? null,
+        requestStreamReconnect: () => eventStreamRef?.reconnect(),
+        reloadConfig: async () => {
+            const next = loadConfig();
+            if (!next?.url || !next?.apiKey)
+                return 'reload skipped: config missing';
+            const disruptive = next.url !== config.url ||
+                next.apiKey !== config.apiKey;
+            Object.assign(config, next);
+            return disruptive ? 'reloaded (disruptive — server/apiKey need restart)' : 'reloaded';
+        },
+    });
+    const fsBrowser = new FsBrowser(config, config.fs_browser || null);
+    log('fs_browser: always-on (ST-7) — construction OK, ready to handle fs_request events');
+    const subagentMonitor = new SubagentMonitor(config, null);
+    subagentManager.setMonitor(subagentMonitor);
+    chatSessionManager.setMonitor(subagentMonitor);
+    ticketSessionManager.setMonitor(subagentMonitor);
+    subagentManager.onExit = ({ record, code, signal, durationSec }) => {
+        const label = record.kind === 'chat' ? 'Chat Subagent' : 'Subagent';
+        let msg;
+        if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+            msg = `[AWB ${label}] ticket=${record.ticket_id || '-'} TIMED OUT after ${durationSec}s`;
+        }
+        else if (code === 0) {
+            msg = `[AWB ${label}] ticket=${record.ticket_id || '-'} completed (duration=${durationSec}s)`;
+        }
+        else {
+            msg = `[AWB ${label}] ticket=${record.ticket_id || '-'} FAILED (exit=${code}, duration=${durationSec}s)`;
+        }
+        log(msg);
+    };
+    try {
+        const dirs = await listManagedAgentDirs();
+        let rehydrated = 0;
+        let skipped = 0;
+        for (const id of dirs) {
+            const cfg = await readManagedAgentConfig(id);
+            const apiKey = await readApiKey(id);
+            if (!cfg || !apiKey || !cfg.working_dir) {
+                skipped++;
+                continue;
+            }
+            await ensureCliHomeDir(id);
+            const credential = await readAgentCredential(id);
+            let extraEnv = {};
+            try {
+                const prep = await createAdapter(cfg.cli).prepareCliHome(cliHomeDirFor(id), credential, { url: config.url, apiKey }, cfg.model || null);
+                extraEnv = prep?.extraEnv ?? {};
+            }
+            catch (err) {
+                log(`rehydrate: cli-home prep failed for agent=${id.slice(0, 8)} cli=${cfg.cli}: ${err?.message ?? err}`);
+            }
+            const credentialKind = !credential
+                ? 'operator_home'
+                : credential.provider.endsWith('_subscription')
+                    ? 'subscription'
+                    : credential.provider.endsWith('_api_key')
+                        ? 'api_key'
+                        : 'subscription';
+            managedAgentContexts.upsert({
+                agent_id: id,
+                name: cfg.name,
+                cli: cfg.cli,
+                working_dir: cfg.working_dir,
+                mcp_config_path: mcpConfigPathFor(id),
+                api_key: apiKey,
+                subagent_log_path: subagentLogPathFor(id),
+                cli_home_dir: cliHomeDirFor(id),
+                model: cfg.model || null,
+                extra_env: extraEnv,
+                credential_provider: credential?.provider ?? null,
+                credential_kind: credentialKind,
+                registered_at: new Date().toISOString(),
+            });
+            managedAgents.upsert({ agent_id: id, name: cfg.name, cli: cfg.cli, working_dir: cfg.working_dir });
+            managedAgents.markRunning(id, process.pid);
+            rehydrated++;
+        }
+        if (rehydrated || skipped) {
+            log(`Managed-agent rehydrate: rehydrated=${rehydrated} skipped=${skipped} (of ${dirs.length} on-disk dirs)`);
+        }
+    }
+    catch (err) {
+        log(`Managed-agent rehydrate failed: ${err?.message ?? err}`);
+    }
+    const eventStream = new EventStream({
+        config,
+        deps: {
+            subagentManager,
+            chatSessionManager,
+            ticketSessionManager,
+            fsBrowser,
+            prompts: promptComposer,
+            agentManagerCommandHandler: commandHandler,
+            managedAgentContexts,
+            worktreeManager,
+            environmentProvisioner,
+        },
+        pluginVersion: version,
+        onConnect: kickPresencePing,
+    });
+    eventStreamRef = eventStream;
+    eventStream.start();
+    log('SSE event stream started');
+    let uploadTimer = null;
+    let worktreeSweepTimer = null;
+    const sweepWorktrees = async () => {
+        if (!worktreeManager.enabled)
+            return;
+        try {
+            const activeKeys = new Set();
+            for (const s of ticketSessionManager._snapshot()) {
+                if (s.ticketId && s.role)
+                    activeKeys.add(worktreeSlug(s.ticketId, s.role));
+            }
+            for (const s of subagentManager._snapshot()) {
+                if (s.ticket_id && s.role)
+                    activeKeys.add(worktreeSlug(s.ticket_id, s.role));
+            }
+            let total = 0;
+            const seenRoots = new Set();
+            for (const ctx of managedAgentContexts.list()) {
+                if (!ctx.working_dir)
+                    continue;
+                const worktreesRoot = pathJoin(MANAGED_AGENTS_DIR, ctx.agent_id, 'worktrees');
+                const dedupeKey = `${ctx.working_dir}${worktreesRoot}`;
+                if (seenRoots.has(dedupeKey))
+                    continue;
+                seenRoots.add(dedupeKey);
+                total += await worktreeManager.sweep({
+                    baseWorkingDir: ctx.working_dir,
+                    worktreesRoot,
+                    activeKeys,
+                });
+            }
+            if (total > 0)
+                log(`[worktree] sweep reclaimed ${total} idle clean worktree(s)`);
+        }
+        catch (err) {
+            log(`[worktree] sweep failed: ${err?.message ?? err}`);
+        }
+    };
+    worktreeSweepTimer = setInterval(() => void sweepWorktrees(), 10 * 60 * 1000);
+    worktreeSweepTimer.unref?.();
+    agentIdReady.then(async (agentId) => {
+        if (!agentId)
+            return;
+        presenceHeartbeat._real = new PresenceHeartbeat(config, agentId);
+        presenceHeartbeat._real.start();
+        const availableModels = {};
+        await Promise.all(KNOWN_ADAPTER_CLI_TYPES.map(async (cli) => {
+            try {
+                const models = await createAdapter(cli).listModels();
+                if (Array.isArray(models) && models.length)
+                    availableModels[cli] = models;
+            }
+            catch (err) {
+                log(`listModels failed for cli=${cli}: ${err?.message ?? err}`);
+            }
+        }));
+        instanceHeartbeat._real = new InstanceHeartbeat(config, agentId, {
+            mode: 'manager',
+            version,
+            cli: 'mixed',
+            cliAdapters: KNOWN_ADAPTER_CLI_TYPES.slice(),
+            availableModels,
+            managedAgents,
+            updateChecker,
+            agentCredentialMetaProvider: async () => {
+                const out = [];
+                for (const ctx of managedAgentContexts.list()) {
+                    if (ctx.credential_kind === 'api_key') {
+                        out.push({
+                            agent_id: ctx.agent_id,
+                            cli: ctx.cli,
+                            kind: 'api_key',
+                            expires_at_ms: null,
+                            refresh_token_present: false,
+                        });
+                        continue;
+                    }
+                    let meta = null;
+                    try {
+                        meta = await createAdapter(ctx.cli).readCredentialMeta(ctx.cli_home_dir);
+                    }
+                    catch (err) {
+                        log(`agentCredentialMetaProvider: read failed for agent=${ctx.agent_id.slice(0, 8)} cli=${ctx.cli}: ${err?.message ?? err}`);
+                        meta = null;
+                    }
+                    if (!meta) {
+                        out.push({
+                            agent_id: ctx.agent_id,
+                            cli: ctx.cli,
+                            kind: ctx.credential_kind === 'operator_home' ? 'operator_home' : 'missing',
+                            expires_at_ms: null,
+                            refresh_token_present: false,
+                        });
+                        continue;
+                    }
+                    const kind = ctx.credential_kind === 'operator_home' && meta.kind === 'subscription'
+                        ? 'operator_home'
+                        : meta.kind;
+                    out.push({
+                        agent_id: ctx.agent_id,
+                        cli: ctx.cli,
+                        kind,
+                        expires_at_ms: meta.expires_at_ms,
+                        refresh_token_present: meta.refresh_token_present,
+                    });
+                }
+                return out;
+            },
+        });
+        instanceHeartbeat._real.start();
+        const fireUpload = () => {
+            uploadIfNewErrors(config, agentId, version).catch(() => { });
+        };
+        fireUpload();
+        uploadTimer = setInterval(fireUpload, 30 * 1000);
+        uploadTimer.unref?.();
+        onFlushThreshold(fireUpload);
+    });
+    const shutdown = async (signal) => {
+        log(`agent-manager received ${signal} — terminating subagents`);
+        presenceHeartbeat._real?.stop();
+        instanceHeartbeat._real?.stop();
+        updateChecker.stop();
+        if (uploadTimer) {
+            clearInterval(uploadTimer);
+            uploadTimer = null;
+        }
+        if (worktreeSweepTimer) {
+            clearInterval(worktreeSweepTimer);
+            worktreeSweepTimer = null;
+        }
+        eventStream.stop();
+        try {
+            await subagentManager.stop();
+        }
+        catch (err) {
+            log(`shutdown: ${err?.message ?? err}`);
+        }
+        try {
+            await chatSessionManager.stop();
+        }
+        catch (err) {
+            log(`shutdown (chat): ${err?.message ?? err}`);
+        }
+        try {
+            await ticketSessionManager.stop();
+        }
+        catch (err) {
+            log(`shutdown (ticket): ${err?.message ?? err}`);
+        }
+        try {
+            subagentMonitor.stop();
+        }
+        catch (err) {
+            log(`shutdown (monitor): ${err?.message ?? err}`);
+        }
+        try {
+            lock.release();
+        }
+        catch (err) {
+            log(`shutdown (lockfile): ${err?.message ?? err}`);
+        }
+        process.exit(isSystemdReExecPending() ? 1 : 0);
+    };
+    process.once('SIGTERM', () => void shutdown('SIGTERM'));
+    process.once('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGUSR1', async () => {
+        try {
+            const result = await runSelfUpdate({ log });
+            log(`Self-update: ${result.summary}`);
+        }
+        catch (err) {
+            log(`Self-update failed: ${err?.stack || err?.message || err}`);
+        }
+    });
+    process.on('SIGHUP', () => {
+        const next = loadConfig();
+        if (!next?.url || !next?.apiKey) {
+            log('SIGHUP: config.json missing or unparseable — keeping previous config');
+            return;
+        }
+        const disruptive = next.url !== config.url ||
+            next.apiKey !== config.apiKey;
+        Object.assign(config, next);
+        log(`SIGHUP: config reloaded (delegation.maxConcurrent=${config.delegation.maxConcurrent} ` +
+            `ttl=${config.delegation.ttlMinutes}min idle=${config.delegation.idleMinutes}min)` +
+            (disruptive ? ' — server/apiKey changes need a manager restart to take effect' : ''));
+    });
+    log('agent-manager ready');
+}
+main().catch((err) => {
+    process.stderr.write(`agent-manager: fatal: ${err?.stack ?? err}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map