thalixtower-cli 0.6.0

package/dist/index.js

@@ -0,0 +1,736 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * atc — the Thalix Tower CLI. Thin client of the hosted /v1 API.
+ * Config: ATC_API + ATC_TOKEN (frequency token from the dashboard). See
+ * docs/AGENT-INTERFACE.md. Exit codes: 0 ok · 1 usage/error · 2 unexpected · 3 conflict.
+ */
+const fs = __importStar(require("node:fs"));
+const child_process = __importStar(require("node:child_process"));
+const client_1 = require("./client");
+const init_1 = require("./init");
+const hook_1 = require("./hook");
+const human_1 = require("./human");
+const VERSION = '0.6.0';
+const COMMANDS = [
+    'init', 'checkin', 'brief', 'standing', 'squawk', 'claim', 'clear',
+    'note', 'notes', 'checkout', 'config',
+    'call', 'traffic',
+    'login', 'logout', 'whoami', 'projects', 'tokens',
+    'hook', 'audit',
+];
+function parseArgs(argv) {
+    const positionals = [];
+    const flags = {};
+    const tags = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const key = a.slice(2);
+            const next = argv[i + 1];
+            const boolFlags = ['pin', 'json', 'yes', 'manual', 'draft', 'activate', 'default', 'none', 'save-token', 'all', 'ack-all'];
+            if (boolFlags.includes(key)) {
+                flags[key] = true;
+            }
+            else if (key === 'tag') {
+                if (next) {
+                    tags.push(next);
+                    i++;
+                }
+            }
+            else if (next && !next.startsWith('--')) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positionals.push(a);
+        }
+    }
+    return { positionals, flags, tags };
+}
+function out(json, human, data) {
+    process.stdout.write(json ? JSON.stringify(data, null, 2) + '\n' : human + '\n');
+}
+function fail(msg, code = 1) {
+    process.stderr.write(`atc: ${msg}\n`);
+    process.exit(code);
+}
+function requireSession() {
+    const s = (0, client_1.loadSession)();
+    if (!s)
+        fail("not checked in — run 'atc checkin' first");
+    return s;
+}
+function renderConflicts(conflicts) {
+    if (!conflicts || conflicts.length === 0)
+        return '✓ no conflicts';
+    return (`⚠ CONFLICT (${conflicts.length}):\n` +
+        conflicts
+            .map((c) => `  ${c.by} holds ${c.theirGlob} (${c.status}, seen ${c.lastSeen}) vs your ${c.glob}`)
+            .join('\n'));
+}
+function printHelp() {
+    process.stdout.write(`atc ${VERSION} — Thalix Tower CLI\n\n` +
+        `Usage: atc <command> [args]\n\n` +
+        `Session commands (human login):\n` +
+        `  login    [--api <url>] [--dashboard <url>] [--manual]\n` +
+        `  logout\n` +
+        `  whoami\n\n` +
+        `Management commands (require atc login):\n` +
+        `  projects [create "<name>"]\n` +
+        `  tokens   --project <id|name>                  list tokens\n` +
+        `  tokens   mint --project <p> [--label l] [--orders a,b,c]\n` +
+        `  tokens   revoke <tokenId>\n` +
+        `  tokens   align <tokenId> --orders a,b,c | --default\n` +
+        `  standing ls     --project <p>\n` +
+        `  standing show   <ref> --project <p>\n` +
+        `  standing create <name> --project <p> (--body "…" | --file f) [--draft]\n` +
+        `  standing edit   <ref>  --project <p> (--body "…" | --file f) [--name n] [--activate|--draft]\n` +
+        `  standing rm     <ref>  --project <p>\n` +
+        `  standing assign --project <p> <name1,name2,…> | --none\n` +
+        `  standing propose <name> (--body "…" | --file f)   (agent plane, uses ATC_TOKEN)\n\n` +
+        `Agent commands (require ATC_API + ATC_TOKEN):\n` +
+        `  init     [--token <freq-token>] [--save-token] [--yes]  wire a project to Thalix Tower\n` +
+        `           --save-token persists the token to .claude/settings.local.json (gitignored)\n` +
+        `  checkin  [--task "..."] [--as <callsign>] [--cli <name>]\n` +
+        `  brief\n` +
+        `  standing               print the frequency's standing orders in full\n` +
+        `  squawk   "<status>" [--code working|blocked|review|mayday]\n` +
+        `  claim    "<glob>"      (exit 3 if it conflicts)\n` +
+        `  clear    ["<glob>"]    (omit glob to release all)\n` +
+        `  note     "<body>" [--tag <t>]... [--pin] [--supersede <id>]\n` +
+        `  note     show <id>     full body of one NOTAM (briefs truncate)\n` +
+        `  notes    [--tag <t>]   list the decision log\n` +
+        `  call     <callsign> "<message>"  send to a callsign (or '*' for everyone)\n` +
+        `  traffic  [--all] [--ack-all] [--ack <id>]  read your inbox\n` +
+        `  checkout\n` +
+        `  config\n\n` +
+        `Tier-3 hook (automatic compliance for Claude Code):\n` +
+        `  hook install [--yes]   wire .claude/settings.json (brief injection, auto-claims, traffic)\n` +
+        `  hook run <event>       hook entrypoint (called by Claude Code; fail-open, never blocks)\n` +
+        `  audit                  compliance rate: edited paths claimed-before-edit this session\n\n` +
+        `Env: ATC_API, ATC_TOKEN, ATC_DASHBOARD. Add --json for raw output.\n`);
+}
+/** Try to open a URL in the default browser (best-effort, never throws). */
+function tryOpenBrowser(url) {
+    const cmds = {
+        darwin: ['open', [url]],
+        linux: ['xdg-open', [url]],
+        win32: ['cmd', ['/c', 'start', url]],
+    };
+    const entry = cmds[process.platform];
+    if (!entry)
+        return;
+    const [bin, args] = entry;
+    try {
+        child_process.spawn(bin, args, { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch {
+        /* ignore */
+    }
+}
+/** Resolve a project ref (id or name) to an id via GET /v1/projects. */
+async function resolveProject(session, ref) {
+    if (ref.startsWith('prj_'))
+        return ref;
+    const r = await (0, human_1.humanApi)(session, 'GET', '/v1/projects');
+    if (!r.ok)
+        fail(r.body?.error ?? `could not list projects (${r.status})`);
+    const projects = r.body.projects ?? [];
+    const byId = projects.find((p) => p.id === ref);
+    if (byId)
+        return byId.id;
+    const matches = projects.filter((p) => p.name.toLowerCase() === ref.toLowerCase());
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length === 0)
+        fail(`no project named "${ref}"`);
+    fail(`ambiguous project name "${ref}" — matches: ${matches.map((p) => `${p.id} (${p.name})`).join(', ')}`);
+}
+/** Read body text from --body "…" or --file f flags. */
+function readBodyFlag(flags) {
+    if (typeof flags.body === 'string')
+        return flags.body;
+    if (typeof flags.file === 'string') {
+        try {
+            return fs.readFileSync(flags.file, 'utf8');
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            fail(`could not read file "${flags.file}": ${msg}`);
+        }
+    }
+    return undefined;
+}
+async function main(argv) {
+    const [cmd, ...rest] = argv;
+    if (!cmd || cmd === '--help' || cmd === '-h')
+        return printHelp();
+    if (cmd === '--version' || cmd === '-v')
+        return void process.stdout.write(VERSION + '\n');
+    if (!COMMANDS.includes(cmd))
+        fail(`unknown command '${cmd}'. Run 'atc --help'.`);
+    const { positionals, flags, tags } = parseArgs(rest);
+    const json = flags.json === true;
+    const cfg = (0, client_1.loadConfig)();
+    // Tier-3 hook entrypoints. `hook run` must NEVER fail a session — it handles
+    // its own errors and always exits 0. Dispatched before any session gate.
+    if (cmd === 'hook') {
+        const sub = positionals[0];
+        if (sub === 'run')
+            return (0, hook_1.runHook)(positionals[1] ?? '');
+        if (sub === 'install')
+            return void (0, hook_1.installHooks)({ yes: flags.yes === true, json });
+        fail('usage: atc hook install | atc hook run <session-start|prompt|pre-edit>');
+    }
+    if (cmd === 'audit') {
+        return (0, hook_1.runAudit)(json);
+    }
+    if (cmd === 'init') {
+        return (0, init_1.runInit)({
+            token: typeof flags.token === 'string' ? flags.token : undefined,
+            saveToken: flags['save-token'] === true,
+            yes: flags.yes === true,
+            json,
+        });
+    }
+    if (cmd === 'config') {
+        return out(json, `api: ${cfg.api || '(unset)'}\ntoken: ${cfg.token ? '(set)' : '(unset)'}`, {
+            api: cfg.api || null,
+            token: cfg.token ? 'set' : null,
+        });
+    }
+    // ---- Human-plane session commands ----
+    if (cmd === 'login') {
+        const apiBase = (typeof flags.api === 'string' ? flags.api : cfg.api || client_1.DEFAULT_API).replace(/\/$/, '');
+        const dashboardBase = (typeof flags.dashboard === 'string'
+            ? flags.dashboard
+            : process.env.ATC_DASHBOARD || 'https://tower.thalixinc.ai').replace(/\/$/, '');
+        const manual = flags.manual === true;
+        // Start the device flow
+        const startRes = await (0, client_1.api)({ api: apiBase, token: '' }, '', 'POST', '/v1/cli-auth/start').catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            fail(`login failed: ${msg}`);
+        });
+        if (!startRes.ok) {
+            fail(startRes.body?.error ?? `login start failed (${startRes.status})`);
+        }
+        const { authId, pollSecret, expiresInSeconds } = startRes.body;
+        const verifyUrl = `${dashboardBase}/cli-auth?code=${authId}`;
+        process.stdout.write(`Open this URL to approve the login:\n  ${verifyUrl}\n`);
+        if (!manual) {
+            tryOpenBrowser(verifyUrl);
+        }
+        // Poll until approved or expired
+        const deadline = Date.now() + expiresInSeconds * 1000;
+        let approved = false;
+        let token = '';
+        let orgId = '';
+        process.stderr.write('Waiting for browser approval');
+        const interval = setInterval(() => process.stderr.write('.'), 2000);
+        const cleanup = () => {
+            clearInterval(interval);
+            process.stderr.write('\n');
+        };
+        // Handle Ctrl-C gracefully
+        process.on('SIGINT', () => {
+            cleanup();
+            process.stderr.write('atc: login cancelled\n');
+            process.exit(1);
+        });
+        while (Date.now() < deadline && !approved) {
+            await new Promise((r) => setTimeout(r, 2000));
+            try {
+                const pollRes = await (0, client_1.api)({ api: apiBase, token: '' }, '', 'GET', `/v1/cli-auth/${encodeURIComponent(authId)}?secret=${encodeURIComponent(pollSecret)}`);
+                if (pollRes.ok && pollRes.body?.status === 'approved') {
+                    approved = true;
+                    token = pollRes.body.token;
+                    orgId = pollRes.body.orgId;
+                }
+            }
+            catch {
+                /* transient network error — keep polling */
+            }
+        }
+        cleanup();
+        if (!approved) {
+            fail('login timed out — run atc login again');
+        }
+        // Fetch identity
+        let userId;
+        try {
+            const meRes = await (0, client_1.api)({ api: apiBase, token }, token, 'GET', '/v1/me');
+            if (meRes.ok) {
+                userId = meRes.body?.userId;
+                orgId = meRes.body?.orgId || orgId;
+            }
+        }
+        catch {
+            /* best-effort */
+        }
+        (0, human_1.saveHuman)({ api: apiBase, token, orgId, userId });
+        return out(json, `logged in as ${userId ?? '(unknown)'} (org ${orgId})`, { userId, orgId });
+    }
+    if (cmd === 'logout') {
+        const session = (0, human_1.loadHuman)();
+        if (session) {
+            try {
+                await (0, human_1.humanApi)(session, 'DELETE', '/v1/cli-auth/session');
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        (0, human_1.clearHuman)();
+        return out(json, 'logged out', { ok: true });
+    }
+    if (cmd === 'whoami') {
+        const session = (0, human_1.requireHuman)(fail);
+        const r = await (0, human_1.humanApi)(session, 'GET', '/v1/me');
+        if (!r.ok)
+            fail(r.body?.error ?? `whoami failed (${r.status})`);
+        return out(json, `userId: ${r.body.userId}\norgId:  ${r.body.orgId}\nrole:   ${r.body.orgRole ?? '(unknown)'}`, r.body);
+    }
+    if (cmd === 'projects') {
+        const session = (0, human_1.requireHuman)(fail);
+        const sub = positionals[0];
+        if (!sub || sub === 'list') {
+            const r = await (0, human_1.humanApi)(session, 'GET', '/v1/projects');
+            if (!r.ok)
+                fail(r.body?.error ?? `projects failed (${r.status})`);
+            const rows = (r.body.projects ?? []);
+            const human = rows.length
+                ? rows.map((p) => `${p.id}  ${p.name}  (${p.status})`).join('\n')
+                : '(no projects)';
+            return out(json, human, r.body);
+        }
+        if (sub === 'create') {
+            const name = positionals[1] ?? (typeof flags.name === 'string' ? flags.name : undefined);
+            if (!name)
+                fail('usage: atc projects create "<name>"');
+            const r = await (0, human_1.humanApi)(session, 'POST', '/v1/projects', { name });
+            if (!r.ok)
+                fail(r.body?.error ?? `projects create failed (${r.status})`);
+            return out(json, `created project ${r.body.id} — ${r.body.name}`, r.body);
+        }
+        fail(`unknown projects subcommand "${sub}"`);
+    }
+    if (cmd === 'tokens') {
+        const session = (0, human_1.requireHuman)(fail);
+        const sub = positionals[0];
+        if (!sub || sub === 'list') {
+            const projectRef = typeof flags.project === 'string' ? flags.project : undefined;
+            if (!projectRef)
+                fail('usage: atc tokens --project <id|name>');
+            const pid = await resolveProject(session, projectRef);
+            const r = await (0, human_1.humanApi)(session, 'GET', `/v1/projects/${encodeURIComponent(pid)}/tokens`);
+            if (!r.ok)
+                fail(r.body?.error ?? `tokens list failed (${r.status})`);
+            const rows = (r.body.tokens ?? []);
+            const human = rows.length
+                ? rows.map((t) => `${t.tokenId}  ${t.label ?? '(no label)'}  ${t.revoked ? '[revoked]' : '[active]'}  ${t.createdAt}`).join('\n')
+                : '(no tokens)';
+            return out(json, human, r.body);
+        }
+        if (sub === 'mint') {
+            const projectRef = typeof flags.project === 'string' ? flags.project : undefined;
+            if (!projectRef)
+                fail('usage: atc tokens mint --project <p> [--label l] [--orders a,b,c]');
+            const pid = await resolveProject(session, projectRef);
+            const label = typeof flags.label === 'string' ? flags.label : undefined;
+            const ordersRaw = typeof flags.orders === 'string' ? flags.orders : undefined;
+            const standingOrderIds = ordersRaw ? ordersRaw.split(',').map((s) => s.trim()).filter(Boolean) : undefined;
+            const r = await (0, human_1.humanApi)(session, 'POST', `/v1/projects/${encodeURIComponent(pid)}/tokens`, {
+                label,
+                standingOrderIds,
+            });
+            if (!r.ok)
+                fail(r.body?.error ?? `tokens mint failed (${r.status})`);
+            const body = r.body;
+            // Token shown ONCE — warning on stderr so --json stdout stays parseable.
+            process.stderr.write(`WARNING: copy this token now — it will not be shown again.\n`);
+            return out(json, `token: ${body.token}\nid:    ${body.tokenId}${body.label ? `\nlabel: ${body.label}` : ''}`, r.body);
+        }
+        if (sub === 'revoke') {
+            const tokenId = positionals[1];
+            if (!tokenId)
+                fail('usage: atc tokens revoke <tokenId>');
+            const r = await (0, human_1.humanApi)(session, 'DELETE', `/v1/tokens/${encodeURIComponent(tokenId)}`);
+            if (!r.ok)
+                fail(r.body?.error ?? `tokens revoke failed (${r.status})`);
+            return out(json, `revoked ${tokenId}`, r.body);
+        }
+        if (sub === 'align') {
+            const tokenId = positionals[1];
+            if (!tokenId)
+                fail('usage: atc tokens align <tokenId> --orders a,b,c | --default');
+            let orders;
+            if (flags.default === true) {
+                orders = null;
+            }
+            else {
+                const ordersRaw = typeof flags.orders === 'string' ? flags.orders : undefined;
+                if (!ordersRaw)
+                    fail('usage: atc tokens align <tokenId> --orders a,b,c | --default');
+                orders = ordersRaw.split(',').map((s) => s.trim()).filter(Boolean);
+            }
+            const r = await (0, human_1.humanApi)(session, 'PUT', `/v1/tokens/${encodeURIComponent(tokenId)}/standing`, { orders });
+            if (!r.ok)
+                fail(r.body?.error ?? `tokens align failed (${r.status})`);
+            return out(json, orders === null ? `${tokenId} → project default` : `${tokenId} → [${orders.join(', ')}]`, r.body);
+        }
+        fail(`unknown tokens subcommand "${sub}"`);
+    }
+    // ---- standing subcommands (management + agent) ----
+    if (cmd === 'standing') {
+        // No sub → agent plane read (existing behaviour; requires ATC_TOKEN session)
+        if (!positionals[0]) {
+            if (!cfg.api || !cfg.token) {
+                fail('ATC_API and ATC_TOKEN must be set (get a frequency token from the dashboard)');
+            }
+            const session = requireSession();
+            const tok = session.sessionToken;
+            const r = await (0, client_1.api)(cfg, tok, 'GET', '/v1/standing');
+            if (!r.ok)
+                fail(r.body?.error ?? `standing failed (${r.status})`, 2);
+            const s = r.body.standing;
+            return out(json, s
+                ? `standing orders (${s.source}): ${s.orders.map((o) => `${o.name} v${o.version}`).join(', ')}\n\n${s.body}`
+                : '(no standing orders assigned to this session)', r.body);
+        }
+        const sub = positionals[0];
+        // propose — agent plane: uses the existing repo session token
+        if (sub === 'propose') {
+            if (!cfg.api || !cfg.token) {
+                fail('ATC_API and ATC_TOKEN must be set (get a frequency token from the dashboard)');
+            }
+            const session = requireSession();
+            const tok = session.sessionToken;
+            const name = positionals[1];
+            if (!name)
+                fail('usage: atc standing propose <name> (--body "…" | --file f)');
+            const body = readBodyFlag(flags);
+            if (!body)
+                fail('usage: atc standing propose <name> (--body "…" | --file f)');
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/standing-orders', { name, body });
+            if (!r.ok)
+                fail(r.body?.error ?? `standing propose failed (${r.status})`, 2);
+            const order = r.body.order ?? r.body;
+            return out(json, `draft ${order.id ?? order.orderId} proposed — a human can activate/assign it`, r.body);
+        }
+        // Management subcommands below all require human login
+        const humanSession = (0, human_1.requireHuman)(fail);
+        const projectRef = typeof flags.project === 'string' ? flags.project : undefined;
+        if (!projectRef && sub !== 'propose') {
+            fail('--project <id|name> is required for standing management commands');
+        }
+        const pid = projectRef ? await resolveProject(humanSession, projectRef) : '';
+        if (sub === 'ls') {
+            const r = await (0, human_1.humanApi)(humanSession, 'GET', `/v1/projects/${encodeURIComponent(pid)}/standing-orders`);
+            if (!r.ok)
+                fail(r.body?.error ?? `standing ls failed (${r.status})`);
+            const { orders, defaultAssignment } = r.body;
+            if (!orders.length)
+                return out(json, '(no standing orders)', r.body);
+            const human = orders
+                .map((o) => {
+                const marker = defaultAssignment.includes(o.id) ? ' [default]' : '';
+                return `${o.id}  ${o.name}  ${o.status}  v${o.version}  ${o.updatedAt}${marker}`;
+            })
+                .join('\n');
+            return out(json, human, r.body);
+        }
+        if (sub === 'show') {
+            const ref = positionals[1];
+            if (!ref)
+                fail('usage: atc standing show <ref> --project <p>');
+            const r = await (0, human_1.humanApi)(humanSession, 'GET', `/v1/projects/${encodeURIComponent(pid)}/standing-orders/${encodeURIComponent(ref)}`);
+            if (!r.ok)
+                fail(r.body?.error ?? `standing show failed (${r.status})`);
+            const { order, history } = r.body;
+            const histLine = history?.length
+                ? `\nhistory: ${history.map((h) => `v${h.version} (${h.updatedAt})`).join(', ')}`
+                : '';
+            return out(json, `[${order.id}] ${order.name}  ${order.status}  v${order.version}  ${order.updatedAt}${histLine}\n\n${order.body}`, r.body);
+        }
+        if (sub === 'create') {
+            const name = positionals[1];
+            if (!name)
+                fail('usage: atc standing create <name> --project <p> (--body "…" | --file f) [--draft]');
+            const body = readBodyFlag(flags);
+            if (!body)
+                fail('--body "…" or --file <path> is required');
+            const status = flags.draft === true ? 'draft' : 'active';
+            const r = await (0, human_1.humanApi)(humanSession, 'POST', `/v1/projects/${encodeURIComponent(pid)}/standing-orders`, {
+                name,
+                body,
+                status,
+            });
+            if (!r.ok)
+                fail(r.body?.error ?? `standing create failed (${r.status})`);
+            const order = r.body.order;
+            return out(json, `created ${order.id}  ${order.name}  ${order.status}`, r.body);
+        }
+        if (sub === 'edit') {
+            const ref = positionals[1];
+            if (!ref)
+                fail('usage: atc standing edit <ref> --project <p> (--body "…" | --file f) [--name n] [--activate|--draft]');
+            const body = readBodyFlag(flags);
+            const name = typeof flags.name === 'string' ? flags.name : undefined;
+            const status = flags.activate === true ? 'active' : flags.draft === true ? 'draft' : undefined;
+            if (!body && !name && !status) {
+                fail('standing edit requires at least one of --body/--file, --name, --activate, or --draft');
+            }
+            const r = await (0, human_1.humanApi)(humanSession, 'PUT', `/v1/projects/${encodeURIComponent(pid)}/standing-orders/${encodeURIComponent(ref)}`, { body, name, status });
+            if (!r.ok)
+                fail(r.body?.error ?? `standing edit failed (${r.status})`);
+            const order = r.body.order;
+            return out(json, `updated ${order.id}  ${order.name}  ${order.status}  v${order.version}`, r.body);
+        }
+        if (sub === 'rm') {
+            const ref = positionals[1];
+            if (!ref)
+                fail('usage: atc standing rm <ref> --project <p>');
+            const r = await (0, human_1.humanApi)(humanSession, 'DELETE', `/v1/projects/${encodeURIComponent(pid)}/standing-orders/${encodeURIComponent(ref)}`);
+            if (!r.ok)
+                fail(r.body?.error ?? `standing rm failed (${r.status})`);
+            return out(json, `deleted ${r.body.deleted ?? ref}`, r.body);
+        }
+        if (sub === 'assign') {
+            if (flags.none === true) {
+                const r = await (0, human_1.humanApi)(humanSession, 'PUT', `/v1/projects/${encodeURIComponent(pid)}/standing-assignment`, { orders: [] });
+                if (!r.ok)
+                    fail(r.body?.error ?? `standing assign failed (${r.status})`);
+                return out(json, 'default assignment cleared', r.body);
+            }
+            // positionals[1] is the comma-separated list, or could be positionals[1..n]
+            const ordersRaw = positionals.slice(1).join(',');
+            if (!ordersRaw)
+                fail('usage: atc standing assign --project <p> <name1,name2,…> | --none');
+            const orders = ordersRaw.split(',').map((s) => s.trim()).filter(Boolean);
+            const r = await (0, human_1.humanApi)(humanSession, 'PUT', `/v1/projects/${encodeURIComponent(pid)}/standing-assignment`, { orders });
+            if (!r.ok)
+                fail(r.body?.error ?? `standing assign failed (${r.status})`);
+            return out(json, `default assignment → [${(r.body.defaultAssignment ?? orders).join(', ')}]`, r.body);
+        }
+        fail(`unknown standing subcommand "${sub}"`);
+    }
+    // ---- Agent-plane commands: require ATC_API + ATC_TOKEN ----
+    if (!cfg.api || !cfg.token) {
+        fail('ATC_API and ATC_TOKEN must be set (get a frequency token from the dashboard)');
+    }
+    if (cmd === 'checkin') {
+        const r = await (0, client_1.api)(cfg, cfg.token, 'POST', '/v1/sessions', {
+            workspaceId: (0, client_1.workspaceId)(),
+            callsign: flags.as,
+            cli: flags.cli || process.env.ATC_CLI || 'cli',
+            worktree: process.cwd(),
+            branch: (0, client_1.currentBranch)(),
+            task: flags.task,
+        });
+        if (!r.ok)
+            fail(r.body?.error ?? `checkin failed (${r.status})`, 2);
+        (0, client_1.saveSession)({ callsign: r.body.callsign, sessionToken: r.body.sessionToken, api: cfg.api });
+        const c = r.body.brief?.counts ?? {};
+        const so = r.body.brief?.standing;
+        const standing = so
+            ? `\n⚑ standing orders present (${(so.orders ?? []).map((o) => o.name).join(', ') || 'assigned'}) — read them: atc standing`
+            : '';
+        const trafficNudge = (c.traffic ?? 0) > 0
+            ? `\n✉ ${c.traffic} messages waiting — atc traffic`
+            : '';
+        return out(json, `checked in as ${r.body.callsign} · ${c.sessions ?? 0} on board, ${c.claims ?? 0} claims, ${c.notams ?? 0} notams${standing}${trafficNudge}`, r.body);
+    }
+    const session = requireSession();
+    const tok = session.sessionToken;
+    switch (cmd) {
+        case 'brief': {
+            const r = await (0, client_1.api)(cfg, tok, 'GET', '/v1/brief');
+            if (!r.ok)
+                fail(r.body?.error ?? `brief failed (${r.status})`, 2);
+            const b = r.body;
+            const standingLine = b.standing
+                ? `standing orders (${b.standing.source}): ${b.standing.orders.map((o) => o.name).join(', ')}` +
+                    `${b.standing.truncated ? ' (truncated here — atc standing for full)' : ''}\n${b.standing.body}\n---\n`
+                : '';
+            const who = (x) => `${x.callsign}(${x.code ?? x.statusText ?? x.status ?? 'working'}${x.claimCount ? `, ${x.claimCount} claims` : ''})`;
+            const trafficLine = (b.traffic?.unacked ?? 0) > 0
+                ? `\ntraffic: ${b.traffic.unacked} unacked\n  ✉ ${b.traffic.preview[0]?.from}: ${b.traffic.preview[0]?.body}`
+                : '\ntraffic: 0 unacked';
+            const human = standingLine +
+                `roster: ${b.roster.map(who).join(', ') || '(none)'}\n` +
+                `claims: ${b.claims.map((x) => `${x.callsign}:${x.glob}`).join(', ') || '(none)'}` +
+                (b.counts.claims > b.claims.length ? ` (+${b.counts.claims - b.claims.length} more on board)` : '') +
+                `\n` +
+                renderConflicts(b.conflictsWithMine) +
+                trafficLine +
+                `\nnotams: ${b.notams.length} shown (pinned + recent; truncated bodies — 'atc note show <id>' for full)`;
+            return out(json, human, b);
+        }
+        case 'squawk': {
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/squawk', {
+                status: positionals.join(' ') || undefined,
+                code: flags.code,
+            });
+            if (!r.ok)
+                fail(r.body?.error ?? `squawk failed (${r.status})`, 2);
+            const squawkConflicts = renderConflicts(r.body.conflictsWithMine);
+            const unackedTraffic = r.body.unackedTraffic ?? 0;
+            const trafficHint = unackedTraffic > 0 ? `\n✉ ${unackedTraffic} unacked — atc traffic` : '';
+            return out(json, squawkConflicts + trafficHint, r.body);
+        }
+        case 'call': {
+            const callsign = positionals[0];
+            if (!callsign)
+                fail('usage: atc call <callsign> "<message>"');
+            const message = typeof flags.body === 'string' ? flags.body : positionals.slice(1).join(' ');
+            if (!message)
+                fail('usage: atc call <callsign> "<message>"');
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/calls', { to: callsign, body: message });
+            if (!r.ok)
+                fail(r.body?.error ?? `call failed (${r.status})`, 2);
+            const delivered = r.body.delivered ?? [];
+            let human;
+            if (callsign === '*') {
+                human = `→ *: delivered to [${delivered.join(', ')}]`;
+            }
+            else {
+                human = `→ ${callsign}: delivered`;
+                if (r.body.recipientActive === false) {
+                    human += '\n(offline — queued for next checkin)';
+                }
+            }
+            return out(json, human, r.body);
+        }
+        case 'traffic': {
+            const all = flags.all === true;
+            const ackAll = flags['ack-all'] === true;
+            const ackId = typeof flags.ack === 'string' ? flags.ack : undefined;
+            const q = all ? '?all=1' : '';
+            const r = await (0, client_1.api)(cfg, tok, 'GET', `/v1/traffic${q}`);
+            if (!r.ok)
+                fail(r.body?.error ?? `traffic failed (${r.status})`, 2);
+            const messages = r.body.messages ?? [];
+            const unacked = r.body.unacked ?? 0;
+            const lines = messages.map((m) => {
+                const ackedMark = m.acked ? ' [acked]' : '';
+                return `[${m.id}] from ${m.from} at ${m.createdAt}: ${m.body}${ackedMark}`;
+            });
+            const listHuman = lines.length ? lines.join('\n') : '(no messages)';
+            if (ackAll) {
+                const ackR = await (0, client_1.api)(cfg, tok, 'POST', '/v1/traffic/ack', { all: true });
+                if (!ackR.ok)
+                    fail(ackR.body?.error ?? `ack failed (${ackR.status})`, 2);
+                return out(json, listHuman + `\nacknowledged all`, { ...r.body, acked: ackR.body.acked });
+            }
+            if (ackId) {
+                const ackR = await (0, client_1.api)(cfg, tok, 'POST', '/v1/traffic/ack', { ids: [ackId] });
+                if (!ackR.ok)
+                    fail(ackR.body?.error ?? `ack failed (${ackR.status})`, 2);
+                return out(json, listHuman + `\nacknowledged ${ackId}`, { ...r.body, acked: ackR.body.acked });
+            }
+            const hint = unacked > 0 ? `\n(ack with: atc traffic --ack-all)` : '';
+            return out(json, listHuman + hint, r.body);
+        }
+        case 'claim': {
+            const glob = positionals[0];
+            if (!glob)
+                fail('usage: atc claim "<glob>"');
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/claims', { glob });
+            if (!r.ok)
+                fail(r.body?.error ?? `claim failed (${r.status})`, 2);
+            const conflicts = r.body.conflicts ?? [];
+            out(json, `claimed ${glob}\n${renderConflicts(conflicts)}`, r.body);
+            if (conflicts.length > 0)
+                process.exit(3);
+            return;
+        }
+        case 'clear': {
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/clear', { glob: positionals[0] });
+            if (!r.ok)
+                fail(r.body?.error ?? `clear failed (${r.status})`, 2);
+            return out(json, `cleared: ${(r.body.cleared ?? []).join(', ') || '(none)'}`, r.body);
+        }
+        case 'note': {
+            if (positionals[0] === 'show') {
+                const id = positionals[1];
+                if (!id)
+                    fail('usage: atc note show <id>');
+                const r = await (0, client_1.api)(cfg, tok, 'GET', `/v1/notams/${encodeURIComponent(id)}`);
+                if (!r.ok)
+                    fail(r.body?.error ?? `note show failed (${r.status})`, 2);
+                const n = r.body.notam;
+                return out(json, `${n.pinned ? '📌 ' : ''}[${n.id}] by ${n.author} at ${n.createdAt}` +
+                    `${n.tags?.length ? '  #' + n.tags.join(' #') : ''}${n.superseded ? '  (superseded)' : ''}\n${n.body}`, r.body);
+            }
+            const body = positionals.join(' ');
+            if (!body)
+                fail('usage: atc note "<body>" [--tag t] [--pin] [--supersede <id>] | atc note show <id>');
+            const supersedes = typeof flags.supersede === 'string' ? flags.supersede : undefined;
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/notams', { body, tags, pinned: flags.pin === true, supersedes });
+            if (!r.ok)
+                fail(r.body?.error ?? `note failed (${r.status})`, 2);
+            return out(json, `noted (${r.body.id})`, r.body);
+        }
+        case 'notes': {
+            const q = tags[0] ? `?tag=${encodeURIComponent(tags[0])}` : '';
+            const r = await (0, client_1.api)(cfg, tok, 'GET', `/v1/notams${q}`);
+            if (!r.ok)
+                fail(r.body?.error ?? `notes failed (${r.status})`, 2);
+            const human = (r.body.notams ?? [])
+                .map((n) => `${n.pinned ? '📌 ' : ''}[${n.id}] ${n.body}${n.tags?.length ? '  #' + n.tags.join(' #') : ''}`)
+                .join('\n') || '(no notams)';
+            return out(json, human, r.body);
+        }
+        case 'checkout': {
+            const r = await (0, client_1.api)(cfg, tok, 'POST', '/v1/checkout');
+            (0, client_1.clearSession)();
+            if (!r.ok)
+                fail(r.body?.error ?? `checkout failed (${r.status})`, 2);
+            return out(json, 'checked out', r.body);
+        }
+        default:
+            fail(`command '${cmd}' not wired`);
+    }
+}
+main(process.argv.slice(2)).catch((err) => {
+    process.stderr.write(`atc: ${err?.message ?? err}\n`);
+    process.exit(2);
+});