@tt-a1i/hive 1.4.4 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 1.5.0 - 2026-05-31
+
+Workflow runtime, experimental team automation, and Codex reliability.
+
+- Adds the experimental Hive workflow runtime: Orchestrators can author
+  multi-agent workflow scripts that fan out across real Hive PTY workers, show
+  runs in the Workflows drawer, stop runs, inspect run details, schedule
+  recurring workflows, and route workflow reports back into the Orchestrator.
+- Adds workflow agent CLI policy settings so users can choose which CLI
+  workflow-created agents use by default and which CLIs are allowed.
+- Adds the experimental auto-staff setting, letting the Orchestrator size the
+  worker roster to the task and prefer task-scoped ephemeral workers when it
+  needs temporary coders, testers, or reviewers.
+- Adds an in-app What's New dialog so future upgrades can surface curated
+  release highlights without requiring users to read the changelog manually.
+- Improves Codex reliability by waiting for pasted-content acknowledgements on
+  long dispatches while submitting short report/status injections quickly,
+  avoiding the several-second delay before reports reach the Orchestrator.
+- Hardens Windows and runtime edge cases, including malformed WebSocket frames,
+  stale nvm4w Codex node entrypoints, workflow worker exits, and additional
+  workflow/runtime cleanup paths.
+
 ## 1.4.4 - 2026-05-29
 
 Windows portability and team protocol hardening.

package/README.md

@@ -241,6 +241,14 @@ pnpm release:dry
 
 Hive 目前处于 alpha 阶段，核心流程已可用。当前重点是继续打磨多 Agent 协作体验、Windows 支持和更清晰的调度可观测性。欢迎试用、提 issue——反馈会直接影响后续节奏。
 
+## 交流群
+
+有问题、想反馈，或者就想聊聊 Agent 协作，欢迎进 QQ 群：**Ai Native 交流群**（群号 `1098836554`）。
+
+<p align="center">
+  <img src="./assets/qq-group.jpg" width="240" alt="Ai Native 交流群 QQ 群二维码，群号 1098836554" />
+</p>
+
 ## 在路上：跨 Agent 的长时记忆
 
 <p align="center">

package/dist/bin/team.cmd

@@ -1,2 +1,3 @@
 @echo off
+setlocal DisableDelayedExpansion
 node "%~dp0..\src\cli\team.js" %*

package/dist/src/cli/hive-update.d.ts

@@ -4,26 +4,36 @@ export interface RunUpdateResult {
     spawnError?: Error;
 }
 export type RunUpdate = (command: string, args: readonly string[]) => Promise<RunUpdateResult>;
+export interface SpawnInvocationPlan {
+    command: string;
+    args: string[];
+    options: {
+        stdio: 'inherit';
+        windowsHide?: boolean;
+    };
+}
 /**
- * Build the spawn options for the upgrade child. The non-obvious part is
- * Windows: npm ships as `npm.cmd` (a batch shim), and Node 22+ refuses to
- * spawn `.cmd` / `.bat` files without `shell: true` after CVE-2024-27980.
- * Detect by file extension rather than by `process.platform` so the same
- * code path works for both real Windows runs and our cross-platform unit
- * tests (which inject `platform: 'win32'` so that `getNpmCommand` returns
- * `npm.cmd`).
+ * Plan how `defaultRunUpdate` should hand the npm invocation to
+ * `child_process.spawn`. Two non-obvious cases collapse here.
+ *
+ * 1. Node 22+ refuses to spawn `.cmd` / `.bat` files directly after
+ *    CVE-2024-27980 unless `shell: true` is passed. We do not want
+ *    `shell: true` though — its arg-stringification path joins argv
+ *    without quoting, so an install prefix containing spaces (the
+ *    common Windows case `C:\Program Files\nodejs`) gets word-split
+ *    by cmd.exe and `--prefix` only sees the first token, so npm
+ *    silently installs hive to the wrong directory.
+ * 2. Wrapping with `cmd.exe /d /s /c <npm.cmd> <args>` solves both:
+ *    spawning `cmd.exe` (a native exe) avoids the .cmd refusal, and
+ *    Node's own argv-quoting builds an lpCommandLine where each
+ *    space-containing arg is wrapped in double quotes that cmd.exe
+ *    then re-parses correctly. `/d` skips AutoRun, `/s` keeps the
+ *    quote-handling consistent with `/c`.
  *
- * Known limitation: with `shell: true` the args are stringified through
- * cmd.exe without quoting, so an install prefix containing spaces (e.g.
- * `C:\Program Files\nodejs`) will be tokenized incorrectly. The common
- * Windows prefix `%APPDATA%\npm` does not have this problem; fixing the
- * spaces case requires a verbatim `cmd.exe /d /s /c call npm.cmd …`
- * wrapper similar to `agent-command-resolver` and is tracked separately.
+ * Detect by filename suffix instead of `process.platform` so unit
+ * tests can inject `platform: 'win32'` and exercise the wrap.
  */
-export declare const buildSpawnOptionsForCommand: (command: string) => {
-    shell: boolean;
-    stdio: "inherit";
-};
+export declare const planSpawnInvocation: (command: string, args: readonly string[], platform?: NodeJS.Platform) => SpawnInvocationPlan;
 /**
  * Signals the upgrade child should receive when the parent runtime is
  * interrupted. Beyond the POSIX-only SIGTERM/SIGINT, SIGHUP is what
@@ -33,6 +43,24 @@ export declare const buildSpawnOptionsForCommand: (command: string) => {
  * Windows exit paths.
  */
 export declare const FORWARDED_UPDATE_SIGNALS: readonly NodeJS.Signals[];
+/**
+ * Forward a parent-process signal to the spawned npm child. On POSIX
+ * we hand the signal straight to the child; on Windows there are no
+ * real signals, so `child.kill(SIGTERM)` resolves to TerminateProcess
+ * against cmd.exe (our wrapper) only — npm itself, plus any install
+ * scripts it spawned, become orphans. `taskkill /pid <pid> /t /f`
+ * walks the wrapper's process tree so the whole branch dies together.
+ * If taskkill is unavailable (restricted PATH, locked-down policy)
+ * we fall back to `child.kill` so the wrapper at least exits.
+ *
+ * Exported so the win32 path can be unit-tested by injecting a stub
+ * `killTree` runner — the real `taskkillProcessTree` shells out, and
+ * we don't want that running during the test suite.
+ */
+export declare const killUpdateChild: (child: {
+    pid?: number | undefined;
+    kill: (signal: NodeJS.Signals) => boolean;
+}, signal: NodeJS.Signals, platform?: NodeJS.Platform, killTree?: (pid: number, onFailure?: () => void) => boolean) => void;
 export declare const defaultRunUpdate: RunUpdate;
 export declare const resolveHiveUpdateInstallArgs: (moduleUrl?: string) => string[];
 interface RunHiveUpdateOptions {

package/dist/src/cli/hive-update.js

@@ -2,7 +2,9 @@ import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { taskkillProcessTree } from '../server/agent-manager-support.js';
 import { getNpmCommand, INSTALL_COMMAND_ARGS, INSTALL_COMMAND_DISPLAY, PACKAGE_NAME, } from '../server/package-version.js';
+import { buildCmdCallCommand } from '../server/windows-command-line.js';
 export const HIVE_UPDATE_USAGE = [
     'Usage:',
     '  hive update',
@@ -20,25 +22,36 @@ export const HIVE_UPDATE_USAGE = [
     '  -h, --help      Print this help.',
 ].join('\n');
 /**
- * Build the spawn options for the upgrade child. The non-obvious part is
- * Windows: npm ships as `npm.cmd` (a batch shim), and Node 22+ refuses to
- * spawn `.cmd` / `.bat` files without `shell: true` after CVE-2024-27980.
- * Detect by file extension rather than by `process.platform` so the same
- * code path works for both real Windows runs and our cross-platform unit
- * tests (which inject `platform: 'win32'` so that `getNpmCommand` returns
- * `npm.cmd`).
+ * Plan how `defaultRunUpdate` should hand the npm invocation to
+ * `child_process.spawn`. Two non-obvious cases collapse here.
  *
- * Known limitation: with `shell: true` the args are stringified through
- * cmd.exe without quoting, so an install prefix containing spaces (e.g.
- * `C:\Program Files\nodejs`) will be tokenized incorrectly. The common
- * Windows prefix `%APPDATA%\npm` does not have this problem; fixing the
- * spaces case requires a verbatim `cmd.exe /d /s /c call npm.cmd …`
- * wrapper similar to `agent-command-resolver` and is tracked separately.
+ * 1. Node 22+ refuses to spawn `.cmd` / `.bat` files directly after
+ *    CVE-2024-27980 unless `shell: true` is passed. We do not want
+ *    `shell: true` though — its arg-stringification path joins argv
+ *    without quoting, so an install prefix containing spaces (the
+ *    common Windows case `C:\Program Files\nodejs`) gets word-split
+ *    by cmd.exe and `--prefix` only sees the first token, so npm
+ *    silently installs hive to the wrong directory.
+ * 2. Wrapping with `cmd.exe /d /s /c <npm.cmd> <args>` solves both:
+ *    spawning `cmd.exe` (a native exe) avoids the .cmd refusal, and
+ *    Node's own argv-quoting builds an lpCommandLine where each
+ *    space-containing arg is wrapped in double quotes that cmd.exe
+ *    then re-parses correctly. `/d` skips AutoRun, `/s` keeps the
+ *    quote-handling consistent with `/c`.
+ *
+ * Detect by filename suffix instead of `process.platform` so unit
+ * tests can inject `platform: 'win32'` and exercise the wrap.
  */
-export const buildSpawnOptionsForCommand = (command) => ({
-    shell: /\.(cmd|bat)$/i.test(command),
-    stdio: 'inherit',
-});
+export const planSpawnInvocation = (command, args, platform = process.platform) => {
+    if (platform === 'win32' && /\.(cmd|bat)$/i.test(command)) {
+        return {
+            command: 'cmd.exe',
+            args: ['/d', '/s', '/c', buildCmdCallCommand(command, args)],
+            options: { stdio: 'inherit', windowsHide: false },
+        };
+    }
+    return { command, args: [...args], options: { stdio: 'inherit' } };
+};
 /**
  * Signals the upgrade child should receive when the parent runtime is
  * interrupted. Beyond the POSIX-only SIGTERM/SIGINT, SIGHUP is what
@@ -53,21 +66,46 @@ export const FORWARDED_UPDATE_SIGNALS = [
     'SIGHUP',
     'SIGBREAK',
 ];
+/**
+ * Forward a parent-process signal to the spawned npm child. On POSIX
+ * we hand the signal straight to the child; on Windows there are no
+ * real signals, so `child.kill(SIGTERM)` resolves to TerminateProcess
+ * against cmd.exe (our wrapper) only — npm itself, plus any install
+ * scripts it spawned, become orphans. `taskkill /pid <pid> /t /f`
+ * walks the wrapper's process tree so the whole branch dies together.
+ * If taskkill is unavailable (restricted PATH, locked-down policy)
+ * we fall back to `child.kill` so the wrapper at least exits.
+ *
+ * Exported so the win32 path can be unit-tested by injecting a stub
+ * `killTree` runner — the real `taskkillProcessTree` shells out, and
+ * we don't want that running during the test suite.
+ */
+export const killUpdateChild = (child, signal, platform = process.platform, killTree = (pid, onFailure) => taskkillProcessTree(pid, platform, undefined, onFailure)) => {
+    const fallback = () => {
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // child.kill on Windows throws if the signal name isn't
+            // implemented; we forward what we can and ignore the rest.
+        }
+    };
+    if (platform === 'win32' && typeof child.pid === 'number' && child.pid > 0) {
+        if (killTree(child.pid, fallback))
+            return;
+    }
+    fallback();
+};
 export const defaultRunUpdate = (command, args) => new Promise((resolve) => {
-    const child = spawn(command, [...args], buildSpawnOptionsForCommand(command));
+    const plan = planSpawnInvocation(command, args);
+    const child = spawn(plan.command, plan.args, plan.options);
     let resolved = false;
     // Handlers are registered with `once` so they don't accumulate
     // across invocations and explicitly removed at finalize().
     const handlers = new Map();
     for (const signal of FORWARDED_UPDATE_SIGNALS) {
         const handler = () => {
-            try {
-                child.kill(signal);
-            }
-            catch {
-                // child.kill on Windows throws if the signal name isn't
-                // implemented; we forward what we can and ignore the rest.
-            }
+            killUpdateChild(child, signal);
         };
         handlers.set(signal, handler);
         process.once(signal, handler);

package/dist/src/cli/hive.d.ts

@@ -33,6 +33,31 @@ type RunHiveCommandOptions = {
 export declare const SHUTDOWN_SIGNALS: readonly ["SIGINT", "SIGTERM", "SIGHUP", "SIGBREAK"];
 export declare const HIVE_USAGE: string;
 export declare const handleHiveInfoCommand: (argv: string[]) => boolean;
+/**
+ * Resolve the directory where Hive persists its SQLite DB and supporting
+ * state. Platform-aware because `~/.config/hive` is a hidden dot-directory
+ * convention that Windows Explorer treats as second-class — Windows users
+ * can't navigate there from the address bar without typing the full path,
+ * and the standard roaming-profile location is `%APPDATA%\<app>` instead.
+ *
+ * Resolution order:
+ *   1. HIVE_DATA_DIR override (any platform, for tests / opinionated users).
+ *   2. Windows: %APPDATA%\hive — roaming user state, follows the user
+ *      across machines on a domain profile. APPDATA, not LOCALAPPDATA,
+ *      because Hive's DB is user data, not a machine-local cache.
+ *      Falls back to homedir()\AppData\Roaming\hive when APPDATA is
+ *      stripped from the env (some Windows Task Scheduler configs do this).
+ *   3. POSIX: $XDG_CONFIG_HOME/hive, falling back to ~/.config/hive.
+ *
+ * Migration: pre-fix Windows installs wrote to ~/.config/hive. When that
+ * legacy directory exists but the new %APPDATA%\hive does not, prefer the
+ * legacy path so an upgrade does not surface as an empty workspace list.
+ * This is a one-way ratchet — once the new location is populated, it wins.
+ *
+ * Exported so the resolution rules are unit-testable without touching env
+ * or the real filesystem.
+ */
+export declare const resolveDataDir: (platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, pathExists?: (path: string) => boolean) => string;
 /**
  * Recovery hint formatter for the "port already in use" error. Platform-aware
  * because the lsof / xargs / kill pipeline is POSIX-only; on Windows a user

package/dist/src/cli/hive.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { once } from 'node:events';
-import { realpathSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createAgentManager } from '../server/agent-manager.js';
 import { createApp } from '../server/app.js';
 import { readPackageVersion } from '../server/package-version.js';
+import { sameFilesystemPath } from '../server/path-canonicalization.js';
 import { createRuntimeStore } from '../server/runtime-store.js';
 import { createVersionService } from '../server/version-service.js';
 import { runHiveUpdateCommand } from './hive-update.js';
@@ -80,7 +81,44 @@ const parsePort = (argv) => {
     }
     return parsedPort ?? 3000;
 };
-const resolveDataDir = () => process.env.HIVE_DATA_DIR || join(homedir(), '.config', 'hive');
+/**
+ * Resolve the directory where Hive persists its SQLite DB and supporting
+ * state. Platform-aware because `~/.config/hive` is a hidden dot-directory
+ * convention that Windows Explorer treats as second-class — Windows users
+ * can't navigate there from the address bar without typing the full path,
+ * and the standard roaming-profile location is `%APPDATA%\<app>` instead.
+ *
+ * Resolution order:
+ *   1. HIVE_DATA_DIR override (any platform, for tests / opinionated users).
+ *   2. Windows: %APPDATA%\hive — roaming user state, follows the user
+ *      across machines on a domain profile. APPDATA, not LOCALAPPDATA,
+ *      because Hive's DB is user data, not a machine-local cache.
+ *      Falls back to homedir()\AppData\Roaming\hive when APPDATA is
+ *      stripped from the env (some Windows Task Scheduler configs do this).
+ *   3. POSIX: $XDG_CONFIG_HOME/hive, falling back to ~/.config/hive.
+ *
+ * Migration: pre-fix Windows installs wrote to ~/.config/hive. When that
+ * legacy directory exists but the new %APPDATA%\hive does not, prefer the
+ * legacy path so an upgrade does not surface as an empty workspace list.
+ * This is a one-way ratchet — once the new location is populated, it wins.
+ *
+ * Exported so the resolution rules are unit-testable without touching env
+ * or the real filesystem.
+ */
+export const resolveDataDir = (platform = process.platform, env = process.env, pathExists = existsSync) => {
+    const override = env.HIVE_DATA_DIR;
+    if (override)
+        return override;
+    if (platform === 'win32') {
+        const appData = env.APPDATA ?? join(homedir(), 'AppData', 'Roaming');
+        const target = join(appData, 'hive');
+        const legacy = join(homedir(), '.config', 'hive');
+        if (!pathExists(target) && pathExists(legacy))
+            return legacy;
+        return target;
+    }
+    return join(env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'hive');
+};
 const maybePrintUpdateHint = async (versionService) => {
     const info = await versionService.getVersionInfo();
     if (!info.update_available)
@@ -210,7 +248,7 @@ export const runHiveCommand = async (argv, options = {}) => {
     };
 };
 const isMainModule = process.argv[1]
-    ? fileURLToPath(import.meta.url) === realpathSync(process.argv[1])
+    ? sameFilesystemPath(fileURLToPath(import.meta.url), process.argv[1])
     : false;
 if (isMainModule) {
     const argv = process.argv.slice(2);

package/dist/src/cli/team.d.ts

@@ -10,6 +10,7 @@ export interface ParsedReportArgs {
 }
 export declare const parseReportArgs: (args: string[], command?: string) => ParsedReportArgs;
 export declare const parseCancelArgs: (args: string[]) => ParsedCancelArgs;
+export declare const decodeStdinBuffer: (buffer: Buffer) => string;
 export declare const readStdinToString: (command?: string) => Promise<string>;
 export declare const runTeamCommand: (argv: string[]) => Promise<void>;
 export {};

package/dist/src/cli/team.js

@@ -1,5 +1,5 @@
-import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { sameFilesystemPath } from '../server/path-canonicalization.js';
 const REQUIRED_ENV_KEYS = [
     'HIVE_PORT',
     'HIVE_PROJECT_ID',
@@ -10,6 +10,13 @@ const TEAM_USAGE = [
     'Usage:',
     '  team list',
     '  team send <worker-name> "<task>"',
+    '  team spawn <role> [--name <name>] [--cli <claude|codex|opencode|gemini>] [--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>]',
@@ -35,6 +42,15 @@ const getHiveEnv = () => {
     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 uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const describeFetchError = (baseUrl, error) => {
     const cause = error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : '';
@@ -177,6 +193,20 @@ export const parseCancelArgs = (args) => {
     }
     return { dispatchId, reason };
 };
+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));
@@ -185,7 +215,7 @@ export const readStdinToString = async (command = 'report') => {
     for await (const chunk of process.stdin) {
         chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
     }
-    const content = Buffer.concat(chunks).toString('utf8');
+    const content = decodeStdinBuffer(Buffer.concat(chunks));
     if (!content.trim()) {
         throw new Error(withUsage('--stdin received empty input', command));
     }
@@ -241,6 +271,172 @@ export const runTeamCommand = async (argv) => {
         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>] [--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();
@@ -294,7 +490,7 @@ export const runTeamCommand = async (argv) => {
     throw new Error('Unsupported team command');
 };
 const isMainModule = process.argv[1]
-    ? fileURLToPath(import.meta.url) === realpathSync(process.argv[1])
+    ? sameFilesystemPath(fileURLToPath(import.meta.url), process.argv[1])
     : false;
 if (isMainModule) {
     void runTeamCommand(process.argv.slice(2)).catch((error) => {

package/dist/src/server/agent-command-resolver.js

@@ -1,5 +1,6 @@
 import { accessSync, constants } from 'node:fs';
 import { basename, delimiter, extname, isAbsolute, join } from 'node:path';
+import { buildCmdCallCommand } from './windows-command-line.js';
 const hasPathSeparator = (command) => command.includes('/') || command.includes('\\');
 const canExecute = (path, platform = process.platform) => {
     try {
@@ -54,28 +55,11 @@ const isWindowsBatchFile = (command) => {
     const extension = extname(command).toLowerCase();
     return extension === '.cmd' || extension === '.bat';
 };
-/**
- * cmd.exe-style escape: doubles inner `"` (cmd's only literal-quote idiom)
- * and only wraps in `"..."` when the token contains whitespace or a cmd
- * metachar. Plain alnum/path tokens stay unquoted, which is the form
- * cmd.exe parses most predictably.
- *
- * Crucially, we do NOT use the `\"` form that the previous implementation
- * used and that node-pty's `argsToCommandLine` produces: cmd doesn't honor
- * backslash-quote escapes in its own command-line parsing.
- */
-const escapeCmdToken = (value) => {
-    if (value.length === 0)
-        return '""';
-    const doubled = value.replace(/"/g, '""');
-    return /[\s"&<>|^()]/.test(value) ? `"${doubled}"` : doubled;
-};
 const buildWindowsBatchCommandLine = (command, args) => {
-    const tokens = [command, ...args].map(escapeCmdToken).join(' ');
     // `call` is cmd's built-in batch invocation; it handles quoted .cmd / .bat
     // paths reliably (this is the same pattern Node.js's child_process uses
     // internally on Windows since the CVE-2024-27980 fix).
-    return `/d /s /c call ${tokens}`;
+    return `/d /s /c ${buildCmdCallCommand(command, args)}`;
 };
 /**
  * Recognize the exact shape that `createStartupCommandLaunch` produces on
@@ -93,7 +77,7 @@ const isCmdExeShellLaunch = (resolvedCommand, args) => basename(resolvedCommand)
     args.length === 4 &&
     args[0] === '/d' &&
     args[1] === '/s' &&
-    args[2] === '/c';
+    (args[2] === '/c' || args[2] === '/k');
 export const resolveSpawnCommand = (command, cwd, env, args = [], platform = process.platform) => {
     const resolvedCommand = resolveCommandPath(command, cwd, env, platform);
     if (platform === 'win32' && isWindowsBatchFile(resolvedCommand)) {