npm - hivehq - Versions diffs - 2.0.0 - Mend

hivehq 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (883) hide show

package/dist/src/cli/team.js ADDED Viewed

@@ -0,0 +1,762 @@
+import { fileURLToPath } from 'node:url';
+import { sameFilesystemPath } from '../server/path-canonicalization.js';
+import { isMemoryKind, MEMORY_BODY_MAX_CHARS, MEMORY_KINDS, MEMORY_QUERY_MAX_CHARS, MEMORY_SEARCH_MAX_LIMIT, MEMORY_TAG_MAX_CHARS, MEMORY_TAG_MAX_COUNT, } from '../shared/team-memory.js';
+import { RECALL_QUERY_MAX_CHARS } from '../shared/team-recall.js';
+const REQUIRED_ENV_KEYS = [
+    'HIVE_PORT',
+    'HIVE_PROJECT_ID',
+    'HIVE_AGENT_ID',
+    'HIVE_AGENT_TOKEN',
+];
+const TEAM_USAGE = [
+    'Usage:',
+    '  team list',
+    '  team next   (tasks in .hive/tasks.md that are unblocked now — those whose [needs: #n] deps are all done)',
+    '  team recall "<query>" [--limit <n>] [--window <n>]',
+    '  team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]',
+    '  team memory show <memory-id>',
+    '  team memory search "<query>" [--limit <n>]',
+    '  team memory forget <memory-id>',
+    '  team send <worker-name> "<task>"',
+    '  team spawn <role> [--name <name>] [--cli <claude|codex|opencode|gemini|hermes>] [--ephemeral]',
+    '  team dismiss <worker-name>',
+    "  team workflow run --stdin [--args '<JSON>']   (script from stdin — for multi-line scripts)",
+    '  team workflow run --inline "<source>" [--args \'<JSON>\']',
+    '  team workflow stop <run-id>',
+    '  team workflow show <run-id>   (full per-agent transcript for one run)',
+    '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)',
+    '  team cancel --dispatch <dispatch-id> "<reason>"',
+    '  team report "<result>" [--dispatch <dispatch-id>] [--artifact <path>]',
+    '  team report --stdin [--dispatch <dispatch-id>] [--artifact <path>]',
+    '  team status "<current status>" [--artifact <path>]',
+    '  team status --stdin [--artifact <path>]',
+    '',
+    'Flags can appear in any order. Use --stdin to pipe long bodies and avoid shell-escaping issues.',
+    'The body comes from stdin — use whatever your shell supports:',
+    "  POSIX:        team report --stdin --dispatch <id> <<'EOF'",
+    '                ... long report ...',
+    '                EOF',
+    '  Windows cmd:  type body.txt | team report --stdin --dispatch <id>',
+    '  PowerShell:   Get-Content -Raw -Encoding utf8 body.txt | team report --stdin --dispatch <id>',
+    '  Portable:     team report --stdin --dispatch <id> < body.txt',
+    '',
+    'For role rules, workflow, and recovery instructions, see .hive/PROTOCOL.md',
+].join('\n');
+const getHiveEnv = () => {
+    const values = Object.fromEntries(REQUIRED_ENV_KEYS.map((key) => [key, process.env[key]]));
+    if (REQUIRED_ENV_KEYS.some((key) => !values[key])) {
+        throw new Error('Missing required Hive environment variables');
+    }
+    return values;
+};
+const getBaseUrl = (env) => `http://127.0.0.1:${env.HIVE_PORT}`;
+// Read `--flag value` from an argv slice; returns undefined when absent or
+// when the flag is the last token with no following value.
+const readFlag = (args, flag) => {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    return value && !value.startsWith('--') ? value : undefined;
+};
+const describeFetchError = (baseUrl, error) => {
+    const cause = error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : '';
+    const message = error instanceof Error ? error.message : String(error);
+    return `Failed to reach Hive runtime at ${baseUrl}: ${message}${cause}. Check HIVE_PORT and make sure the Hive runtime is still running.`;
+};
+const fetchRuntime = async (baseUrl, path, init) => {
+    try {
+        return await fetch(`${baseUrl}${path}`, init);
+    }
+    catch (error) {
+        throw new Error(describeFetchError(baseUrl, error));
+    }
+};
+const readHttpErrorDetail = async (response) => {
+    const text = await response.text().catch(() => '');
+    const trimmed = text.trim();
+    if (!trimmed)
+        return '';
+    try {
+        const body = JSON.parse(trimmed);
+        if (typeof body.error === 'string' && body.error.trim()) {
+            return body.error.trim();
+        }
+    }
+    catch {
+        // Non-JSON responses still carry useful diagnostics in their text body.
+    }
+    return trimmed;
+};
+const throwHttpError = async (response) => {
+    const detail = await readHttpErrorDetail(response);
+    throw new Error(detail
+        ? `Request failed with status ${response.status}: ${detail}`
+        : `Request failed with status ${response.status}`);
+};
+const postJson = async (baseUrl, path, body) => {
+    const response = await fetchRuntime(baseUrl, path, {
+        body: JSON.stringify(body),
+        headers: { 'content-type': 'application/json' },
+        method: 'POST',
+    });
+    if (!response.ok) {
+        await throwHttpError(response);
+    }
+    return response;
+};
+const REPORT_USAGE = 'Usage: team report (<result> | --stdin) [--dispatch <dispatch-id>] [--artifact <path>]';
+const STATUS_USAGE = 'Usage: team status (<current status> | --stdin) [--artifact <path>]';
+const CANCEL_USAGE = 'Usage: team cancel --dispatch <dispatch-id> <reason>';
+const RECALL_USAGE = 'Usage: team recall "<query>" [--limit <n>] [--window <n>]';
+const MEMORY_ADD_USAGE = 'Usage: team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]';
+const MEMORY_SHOW_USAGE = 'Usage: team memory show <memory-id>';
+const MEMORY_SEARCH_USAGE = 'Usage: team memory search "<query>" [--limit <n>]';
+const MEMORY_FORGET_USAGE = 'Usage: team memory forget <memory-id>';
+const usageFor = (command) => (command === 'status' ? STATUS_USAGE : REPORT_USAGE);
+const withUsage = (message, command) => `${message}\n\n${usageFor(command)}`;
+export const parseReportArgs = (args, command = 'report') => {
+    const positionals = [];
+    const artifacts = [];
+    let dispatchId;
+    let useStdin = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        // Backward-compatible no-op: reports are interpreted from their text.
+        if (arg === '--success' || arg === '--failed')
+            continue;
+        if (arg === '--stdin') {
+            useStdin = true;
+            continue;
+        }
+        if (arg === '--artifact') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(withUsage('--artifact requires a value', command));
+            }
+            artifacts.push(next);
+            index += 1;
+            continue;
+        }
+        if (arg === '--dispatch') {
+            if (command === 'status') {
+                throw new Error(withUsage('team status does not accept --dispatch; use team report for assigned work', command));
+            }
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(withUsage('--dispatch requires a value', command));
+            }
+            dispatchId = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(withUsage(`Unknown argument: ${arg}`, command));
+        }
+        positionals.push(arg);
+    }
+    if (useStdin && positionals.length > 0) {
+        throw new Error(withUsage('--stdin is mutually exclusive with a positional argument; pass the body on stdin or as an argument, not both', command));
+    }
+    if (!useStdin && positionals.length === 0) {
+        const label = command === 'status' ? '<current status>' : '<result>';
+        throw new Error(withUsage(`Missing ${label} (or pass --stdin to read it from stdin)`, command));
+    }
+    if (positionals.length > 1) {
+        const label = command === 'status' ? 'status' : 'result';
+        throw new Error(withUsage(`Expected exactly one ${label} positional, got ${positionals.length}: ${positionals
+            .map((value) => JSON.stringify(value))
+            .join(', ')}`, command));
+    }
+    return { result: useStdin ? null : (positionals[0] ?? null), artifacts, dispatchId, useStdin };
+};
+export const parseCancelArgs = (args) => {
+    const positionals = [];
+    let dispatchId;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--dispatch') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--dispatch requires a value\n\n${CANCEL_USAGE}`);
+            }
+            dispatchId = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown argument: ${arg}\n\n${CANCEL_USAGE}`);
+        }
+        positionals.push(arg);
+    }
+    if (!dispatchId) {
+        throw new Error(`Missing --dispatch <dispatch-id>\n\n${CANCEL_USAGE}`);
+    }
+    if (positionals.length === 0) {
+        throw new Error(`Missing <reason>\n\n${CANCEL_USAGE}`);
+    }
+    const reason = positionals.join(' ').trim();
+    if (!reason) {
+        throw new Error(`Missing <reason>\n\n${CANCEL_USAGE}`);
+    }
+    return { dispatchId, reason };
+};
+const parseNonNegativeIntFlag = (value, flag) => {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${flag} must be a non-negative integer\n\n${RECALL_USAGE}`);
+    }
+    return parsed;
+};
+export const parseRecallArgs = (args) => {
+    const positionals = [];
+    let limit;
+    let window;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--limit' || arg === '--window') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`${arg} requires a value\n\n${RECALL_USAGE}`);
+            }
+            if (arg === '--limit')
+                limit = parseNonNegativeIntFlag(next, '--limit');
+            else
+                window = parseNonNegativeIntFlag(next, '--window');
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown argument: ${arg}\n\n${RECALL_USAGE}`);
+        }
+        positionals.push(arg);
+    }
+    if (positionals.length === 0) {
+        throw new Error(`Missing <query>\n\n${RECALL_USAGE}`);
+    }
+    const query = positionals.join(' ').trim();
+    if ([...query].length > RECALL_QUERY_MAX_CHARS) {
+        throw new Error(`query must be ${RECALL_QUERY_MAX_CHARS} characters or fewer\n\n${RECALL_USAGE}`);
+    }
+    return {
+        query,
+        ...(limit !== undefined ? { limit } : {}),
+        ...(window !== undefined ? { window } : {}),
+    };
+};
+export const parseMemoryAddArgs = (args) => {
+    const positionals = [];
+    const tags = [];
+    let kind = 'fact';
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--kind') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--kind requires a value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            if (!isMemoryKind(next)) {
+                throw new Error(`--kind must be one of: ${MEMORY_KINDS.join(', ')}\n\n${MEMORY_ADD_USAGE}`);
+            }
+            kind = next;
+            index += 1;
+            continue;
+        }
+        if (arg === '--tag') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--tag requires a value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            const tag = next.trim();
+            if (!tag) {
+                throw new Error(`--tag requires a non-empty value\n\n${MEMORY_ADD_USAGE}`);
+            }
+            if ([...tag].length > MEMORY_TAG_MAX_CHARS) {
+                throw new Error(`--tag must be ${MEMORY_TAG_MAX_CHARS} characters or fewer\n\n${MEMORY_ADD_USAGE}`);
+            }
+            if (!tags.includes(tag))
+                tags.push(tag);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown argument: ${arg}\n\n${MEMORY_ADD_USAGE}`);
+        }
+        positionals.push(arg);
+    }
+    if (tags.length > MEMORY_TAG_MAX_COUNT) {
+        throw new Error(`--tag may be repeated ${MEMORY_TAG_MAX_COUNT} times or fewer\n\n${MEMORY_ADD_USAGE}`);
+    }
+    if (positionals.length === 0) {
+        throw new Error(`Missing <body>\n\n${MEMORY_ADD_USAGE}`);
+    }
+    const body = positionals.join(' ').trim();
+    if (!body) {
+        throw new Error(`Missing <body>\n\n${MEMORY_ADD_USAGE}`);
+    }
+    if ([...body].length > MEMORY_BODY_MAX_CHARS) {
+        throw new Error(`body must be ${MEMORY_BODY_MAX_CHARS} characters or fewer\n\n${MEMORY_ADD_USAGE}`);
+    }
+    return { body, kind, tags };
+};
+export const parseMemoryShowArgs = (args) => {
+    if (args.length !== 1 || !args[0] || args[0].startsWith('--')) {
+        throw new Error(`Missing <memory-id>\n\n${MEMORY_SHOW_USAGE}`);
+    }
+    return { memoryId: args[0] };
+};
+export const parseMemorySearchArgs = (args) => {
+    const positionals = [];
+    let limit;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--limit') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--limit requires a value\n\n${MEMORY_SEARCH_USAGE}`);
+            }
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed < 0) {
+                throw new Error(`--limit must be a non-negative integer\n\n${MEMORY_SEARCH_USAGE}`);
+            }
+            limit = Math.min(parsed, MEMORY_SEARCH_MAX_LIMIT);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown argument: ${arg}\n\n${MEMORY_SEARCH_USAGE}`);
+        }
+        positionals.push(arg);
+    }
+    if (positionals.length === 0) {
+        throw new Error(`Missing <query>\n\n${MEMORY_SEARCH_USAGE}`);
+    }
+    const query = positionals.join(' ').trim();
+    if (!query) {
+        throw new Error(`Missing <query>\n\n${MEMORY_SEARCH_USAGE}`);
+    }
+    if ([...query].length > MEMORY_QUERY_MAX_CHARS) {
+        throw new Error(`query must be ${MEMORY_QUERY_MAX_CHARS} characters or fewer\n\n${MEMORY_SEARCH_USAGE}`);
+    }
+    return {
+        query,
+        ...(limit !== undefined ? { limit } : {}),
+    };
+};
+export const parseMemoryForgetArgs = (args) => {
+    if (args.length === 0 || !args[0] || args[0].startsWith('--')) {
+        throw new Error(`Missing <memory-id>\n\n${MEMORY_FORGET_USAGE}`);
+    }
+    if (args.length !== 1) {
+        throw new Error(`Expected exactly one <memory-id>\n\n${MEMORY_FORGET_USAGE}`);
+    }
+    return { memoryId: args[0] };
+};
+export const decodeStdinBuffer = (buffer) => {
+    if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+        return buffer.subarray(3).toString('utf8');
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+        return buffer.subarray(2).toString('utf16le');
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
+        const swapped = Buffer.from(buffer.subarray(2));
+        swapped.swap16();
+        return swapped.toString('utf16le');
+    }
+    return buffer.toString('utf8');
+};
+export const readStdinToString = async (command = 'report') => {
+    if (process.stdin.isTTY) {
+        throw new Error(withUsage('--stdin requires piped input, but stdin is a TTY. Did you forget to pipe content in?', command));
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    const content = decodeStdinBuffer(Buffer.concat(chunks));
+    if (!content.trim()) {
+        throw new Error(withUsage('--stdin received empty input', command));
+    }
+    return content;
+};
+export const runTeamCommand = async (argv) => {
+    const [command, ...args] = argv;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        console.log(TEAM_USAGE);
+        return;
+    }
+    if (command === 'list') {
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        const response = await fetchRuntime(baseUrl, `/api/workspaces/${env.HIVE_PROJECT_ID}/team`, {
+            method: 'GET',
+            headers: {
+                'x-hive-agent-id': env.HIVE_AGENT_ID,
+                'x-hive-agent-token': env.HIVE_AGENT_TOKEN,
+            },
+        });
+        if (!response.ok) {
+            await throwHttpError(response);
+        }
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'next') {
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        const response = await fetchRuntime(baseUrl, `/api/workspaces/${env.HIVE_PROJECT_ID}/tasks/next`, {
+            method: 'GET',
+            headers: {
+                'x-hive-agent-id': env.HIVE_AGENT_ID,
+                'x-hive-agent-token': env.HIVE_AGENT_TOKEN,
+            },
+        });
+        if (!response.ok) {
+            await throwHttpError(response);
+        }
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'recall') {
+        const recall = parseRecallArgs(args);
+        const env = getHiveEnv();
+        const response = await postJson(getBaseUrl(env), '/api/team/recall', {
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            query: recall.query,
+            ...(recall.limit !== undefined ? { limit: recall.limit } : {}),
+            ...(recall.window !== undefined ? { window: recall.window } : {}),
+        });
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'memory') {
+        const [subcommand, ...memoryArgs] = args;
+        if (subcommand === 'add') {
+            const memory = parseMemoryAddArgs(memoryArgs);
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/memory/add', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                body: memory.body,
+                kind: memory.kind,
+                tags: memory.tags,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (subcommand === 'show') {
+            const memory = parseMemoryShowArgs(memoryArgs);
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/memory/show', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                memory_id: memory.memoryId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (subcommand === 'search') {
+            const memory = parseMemorySearchArgs(memoryArgs);
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/memory/search', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                query: memory.query,
+                ...(memory.limit !== undefined ? { limit: memory.limit } : {}),
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (subcommand === 'forget') {
+            const memory = parseMemoryForgetArgs(memoryArgs);
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/memory/forget', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                memory_id: memory.memoryId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        throw new Error([
+            'Usage:',
+            `  ${MEMORY_ADD_USAGE}`,
+            `  ${MEMORY_SHOW_USAGE}`,
+            `  ${MEMORY_SEARCH_USAGE}`,
+            `  ${MEMORY_FORGET_USAGE}`,
+        ].join('\n'));
+    }
+    if (command === 'send') {
+        const [workerName, ...taskParts] = args;
+        const task = taskParts.join(' ').trim();
+        if (!workerName || !task) {
+            throw new Error('Usage: team send <worker-name> <task>');
+        }
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        const response = await postJson(baseUrl, '/api/team/send', {
+            hive_port: env.HIVE_PORT,
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            to: workerName,
+            text: task,
+        });
+        const payload = (await response.json());
+        /* When the dispatch happened to also auto-wake a stopped worker
+           (PTY had no active run), make the silent restart visible. Stderr
+           is the right channel because the JSON on stdout is the
+           machine-readable payload; the human-readable narration goes
+           beside it so it doesn't corrupt parsers. */
+        if (payload.restarted_worker === true) {
+            console.error(`Hive woke up worker "${workerName}" before dispatching.`);
+        }
+        console.log(JSON.stringify(payload));
+        return;
+    }
+    if (command === 'spawn') {
+        const role = args[0];
+        if (!role || role.startsWith('--')) {
+            throw new Error('Usage: team spawn <role> [--name <name>] [--cli <claude|codex|opencode|gemini|hermes>] [--ephemeral]\n' +
+                '  Default: persistent member (lives until you `team dismiss` it).\n' +
+                '  --ephemeral: auto-dismiss after the next dispatch report (one-shot worker).');
+        }
+        const name = readFlag(args, '--name');
+        const cli = readFlag(args, '--cli');
+        const ephemeral = args.includes('--ephemeral');
+        const env = getHiveEnv();
+        const response = await postJson(getBaseUrl(env), '/api/team/spawn', {
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            role,
+            ...(name ? { name } : {}),
+            ...(cli ? { cli } : {}),
+            ...(ephemeral ? { ephemeral: true } : {}),
+        });
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'dismiss') {
+        const workerName = args[0];
+        if (!workerName || workerName.startsWith('--')) {
+            throw new Error('Usage: team dismiss <worker-name>');
+        }
+        const env = getHiveEnv();
+        const response = await postJson(getBaseUrl(env), '/api/team/dismiss', {
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            name: workerName,
+        });
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'workflow') {
+        const sub = args[0];
+        const rest = args.slice(1);
+        if (sub === 'run') {
+            const inlineFlag = rest.indexOf('--inline');
+            const stdinFlag = rest.includes('--stdin');
+            const name = readFlag(rest, '--name');
+            // TIER 2 #8 — `--args '<JSON>'` makes the script's `args` global a
+            // real value instead of always undefined. Parses lazily so a bad
+            // JSON gives a clear local error before the HTTP round-trip.
+            const rawArgs = readFlag(rest, '--args');
+            let parsedArgs;
+            if (rawArgs !== undefined) {
+                try {
+                    parsedArgs = JSON.parse(rawArgs);
+                }
+                catch (error) {
+                    throw new Error(`Usage: team workflow run … --args '<JSON>'\n  --args must be valid JSON; got: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            let source;
+            if (inlineFlag !== -1) {
+                const literal = rest[inlineFlag + 1];
+                if (!literal)
+                    throw new Error('Usage: team workflow run --inline "<script-source>"');
+                source = literal;
+            }
+            else if (stdinFlag) {
+                source = await readStdinToString('workflow run');
+            }
+            else {
+                throw new Error('Usage: team workflow run --stdin   |   team workflow run --inline "<script-source>"\n' +
+                    '  Pass workflow source via stdin (POSIX heredoc / `type x.ts |`) or as one inline arg.\n' +
+                    "  Optional: --args '<JSON>' makes the script's `args` global a real value.");
+            }
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/run', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                source,
+                ...(name ? { name } : {}),
+                ...(parsedArgs !== undefined ? { args: parsedArgs } : {}),
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (sub === 'stop') {
+            const runId = rest[0];
+            if (!runId)
+                throw new Error('Usage: team workflow stop <run-id>');
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/stop', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                run_id: runId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (sub === 'show') {
+            const runId = rest[0];
+            if (!runId)
+                throw new Error('Usage: team workflow show <run-id>');
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/show', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                run_id: runId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (sub === 'schedule') {
+            const usage = 'Usage: team workflow schedule --cron "<5-field cron>" --name <name> --stdin\n' +
+                '       team workflow schedule --cron "<cron>" --name <name> --inline "<source>" [--args \'<JSON>\']\n' +
+                '  Registers a recurring run. Source is persisted so cron can fire it with no orchestrator present.';
+            const inlineFlag = rest.indexOf('--inline');
+            const stdinFlag = rest.includes('--stdin');
+            const cron = readFlag(rest, '--cron');
+            const name = readFlag(rest, '--name');
+            if (!cron || !name)
+                throw new Error(usage);
+            const rawArgs = readFlag(rest, '--args');
+            let parsedArgs;
+            if (rawArgs !== undefined) {
+                try {
+                    parsedArgs = JSON.parse(rawArgs);
+                }
+                catch (error) {
+                    throw new Error(`Usage: team workflow schedule … --args '<JSON>'\n  --args must be valid JSON; got: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            let source;
+            if (inlineFlag !== -1) {
+                const literal = rest[inlineFlag + 1];
+                if (!literal)
+                    throw new Error(usage);
+                source = literal;
+            }
+            else if (stdinFlag) {
+                source = await readStdinToString('workflow schedule');
+            }
+            else {
+                throw new Error(usage);
+            }
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/schedule', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                source,
+                name,
+                cron,
+                ...(parsedArgs !== undefined ? { args: parsedArgs } : {}),
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        throw new Error('Usage:\n' +
+            "  team workflow run --stdin [--args '<JSON>']     (read script from stdin)\n" +
+            '  team workflow run --inline "<source>" [--args ...]  (one-arg form)\n' +
+            '  team workflow stop <run-id>                     (cancel a running workflow)\n' +
+            '  team workflow show <run-id>                     (full per-agent transcript)\n' +
+            '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)');
+    }
+    if (command === 'cancel') {
+        const cancel = parseCancelArgs(args);
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        await postJson(baseUrl, '/api/team/cancel', {
+            dispatch_id: cancel.dispatchId,
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            reason: cancel.reason,
+        });
+        return;
+    }
+    if (command === 'status') {
+        const report = parseReportArgs(args, 'status');
+        const body = report.useStdin ? await readStdinToString('status') : (report.result ?? '');
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        const response = await postJson(baseUrl, '/api/team/status', {
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            result: body,
+            artifacts: report.artifacts,
+        });
+        const payload = (await response.json());
+        if (payload.forwarded === false && payload.forward_error) {
+            console.error(`Hive recorded the status update, but could not deliver it to Orchestrator in real time: ${payload.forward_error}`);
+        }
+        return;
+    }
+    if (command === 'report') {
+        const report = parseReportArgs(args);
+        const body = report.useStdin ? await readStdinToString('report') : (report.result ?? '');
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        const response = await postJson(baseUrl, '/api/team/report', {
+            ...(report.dispatchId ? { dispatch_id: report.dispatchId } : {}),
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            result: body,
+            artifacts: report.artifacts,
+        });
+        const payload = (await response.json());
+        if (payload.forwarded === false && payload.forward_error) {
+            console.error(`Hive recorded the report, but could not deliver it to Orchestrator in real time: ${payload.forward_error}`);
+        }
+        return;
+    }
+    throw new Error('Unsupported team command');
+};
+const isMainModule = process.argv[1]
+    ? sameFilesystemPath(fileURLToPath(import.meta.url), process.argv[1])
+    : false;
+if (isMainModule) {
+    void runTeamCommand(process.argv.slice(2)).catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}