@pennixrv/trellis 0.7.0-beta.9 → 0.7.1-beta.0

package/dist/commands/{channel → teamwork}/index.js

@@ -2,66 +2,62 @@ import chalk from "chalk";
 import { InvalidArgumentError } from "commander";
 import { isProvider, listProviders } from "./adapters/index.js";
 import { parseCodexSandboxMode } from "./adapters/codex.js";
-import { channelContextAdd, channelContextDelete, channelContextList, } from "./context.js";
-import { createChannel } from "./create.js";
+import { teamworkSessionContextAdd, teamworkSessionContextDelete, teamworkSessionContextList, } from "./context.js";
+import { createTeamworkSession } from "./create.js";
 import { parseTrace } from "./dev-parse-trace.js";
-import { channelKill } from "./kill.js";
-import { channelInterrupt } from "./interrupt.js";
-import { channelList } from "./list.js";
-import { channelMessages } from "./messages.js";
-import { channelPrune, channelRm } from "./rm.js";
-import { channelSend } from "./send.js";
-import { channelRun } from "./run.js";
-import { channelSpawn } from "./spawn.js";
-import { channelWorkers } from "./workers.js";
-import { channelThreadPost, channelThreadRename, channelThreadShow, channelForumList, } from "./threads.js";
-import { channelTitleClear, channelTitleSet } from "./title.js";
+import { teamworkSessionKill } from "./kill.js";
+import { teamworkSessionInterrupt } from "./interrupt.js";
+import { teamworkSessionList } from "./list.js";
+import { teamworkSessionMessages } from "./messages.js";
+import { teamworkSessionPrune, teamworkSessionRm } from "./rm.js";
+import { teamworkSessionSend } from "./send.js";
+import { teamworkSessionRun } from "./run.js";
+import { teamworkSessionSpawn } from "./spawn.js";
+import { teamworkSessionThreadPost, teamworkSessionThreadRename, teamworkSessionThreadShow, teamworkSessionForumList, } from "./threads.js";
+import { teamworkSessionTitleClear, teamworkSessionTitleSet } from "./title.js";
 import { runSupervisor } from "./supervisor.js";
-import { channelBarrier, channelWait, parseDuration } from "./wait.js";
+import { teamworkSessionWait, parseDuration } from "./wait.js";
 import { parseCsv } from "./store/schema.js";
-import { parseInboxPolicy } from "@pennixrv/trellis-core/channel";
+import { parseInboxPolicy } from "@pennixrv/trellis-core/teamwork";
 function parseNonNegativeInteger(value) {
     if (!/^\d+$/.test(value)) {
         throw new InvalidArgumentError(`expected a non-negative integer, got '${value}'`);
     }
     return Number(value);
 }
-export function registerChannelCommand(program) {
-    const channel = program
-        .command("channel")
-        .description("Multi-agent collaboration runtime — spawn / coordinate / interrupt worker agents through a shared event log");
-    channel
+export function registerTeamworkCommand(program) {
+    const teamwork = program
+        .command("teamwork")
+        .description("Trellis Teamwork runtime — coordinate teammates through a shared event log");
+    teamwork
         .command("create <name>")
-        .description("Create a new channel (collaboration session)")
-        .option("--scope <scope>", "channel scope: project | global")
-        .option("--type <type>", "channel type: chat | forum", "chat")
+        .description("Create a Teamwork session")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
+        .option("--type <type>", "session type: chat | forum", "chat")
         .option("--task <path>", "associated Trellis task directory")
         .option("--project <slug>", "project slug")
         .option("--labels <csv>", "comma-separated labels")
-        .option("--description <text>", "stable channel description")
-        .option("--context-file <absolute-path>", "absolute file path attached as channel context (repeatable)", (val, prev) => [...(prev ?? []), val], [])
-        .option("--context-raw <text>", "raw channel context text (repeatable)", (val, prev) => [...(prev ?? []), val], [])
-        .option("--linked-context-file <absolute-path>", "[deprecated alias for --context-file] absolute file path (repeatable)", (val, prev) => [...(prev ?? []), val], [])
-        .option("--linked-context-raw <text>", "[deprecated alias for --context-raw] raw context text (repeatable)", (val, prev) => [...(prev ?? []), val], [])
+        .option("--description <text>", "stable Teamwork session description")
+        .option("--context-file <absolute-path>", "absolute file path attached as Teamwork session context (repeatable)", (val, prev) => [...(prev ?? []), val], [])
+        .option("--context-raw <text>", "raw Teamwork session context text (repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .option("--cwd <path>", "working directory recorded in the create event")
         .option("--by <agent>", "agent name recorded as the creator", "main")
-        .option("--owner-session <id>", "opaque main Codex session owner (defaults to host session env)")
-        .option("--force", "overwrite existing channel with the same name")
-        .option("--ephemeral", "mark as ephemeral — hidden from `channel list` by default and cleanable via `channel prune --ephemeral`")
+        .option("--force", "overwrite an existing Teamwork session with the same name")
+        .option("--ephemeral", "mark as ephemeral — hidden from `teamwork list` by default and cleanable via `teamwork prune --ephemeral`")
         .action(async (name, opts) => {
         try {
-            await createChannel(name, opts);
+            await createTeamworkSession(name, opts);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("send <name>")
-        .description("Send a message into the channel")
+        .description("Send a message in a Teamwork session")
         .requiredOption("--as <agent>", "agent name sending")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--to <agents>", "comma-separated target agents (default: broadcast)")
         .option("--stdin", "read message body from stdin")
         .option("--text-file <path>", "read message body from file")
@@ -70,7 +66,7 @@ export function registerChannelCommand(program) {
         .action(async (name, text, raw) => {
         const opts = raw;
         try {
-            await channelSend(name, {
+            await teamworkSessionSend(name, {
                 as: opts.as,
                 text,
                 stdin: opts.stdin,
@@ -85,27 +81,12 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
-        .command("barrier <name>")
-        .description("Print the current durable event sequence without appending an event")
-        .option("--scope <scope>", "channel scope: project | global")
-        .action(async (name, raw) => {
-        const opts = raw;
-        try {
-            console.log(await channelBarrier(name, { scope: opts.scope }));
-        }
-        catch (err) {
-            console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
-            process.exit(1);
-        }
-    });
-    channel
+    teamwork
         .command("wait <name>")
         .description("Block until an event matching the filter arrives, or timeout")
         .requiredOption("--as <agent>", "agent name waiting")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--timeout <duration>", "max wait (e.g. 30s, 2m, 1h)")
-        .option("--after-seq <sequence>", "replay only events after this durable sequence barrier", parseNonNegativeInteger)
         .option("--from <agents>", "only wake on events from these agents (CSV)")
         .option("--kind <kind[,kind...]>", "only wake on these event kinds (CSV, OR semantics)")
         .option("--thread <key>", "only wake on this thread key")
@@ -116,10 +97,9 @@ export function registerChannelCommand(program) {
         .action(async (name, raw) => {
         const opts = raw;
         try {
-            await channelWait(name, {
+            await teamworkSessionWait(name, {
                 as: opts.as,
                 timeoutMs: parseDuration(opts.timeout),
-                afterSeq: opts.afterSeq,
                 from: opts.from,
                 kind: opts.kind,
                 scope: opts.scope,
@@ -135,19 +115,19 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("interrupt <name>")
-        .description("Interrupt a worker turn and send a replacement instruction")
+        .description("Interrupt a teammate turn and send a replacement instruction")
         .requiredOption("--as <agent>", "agent name requesting the interrupt")
-        .requiredOption("--to <agent>", "target worker name")
-        .option("--scope <scope>", "channel scope: project | global")
+        .requiredOption("--to <agent>", "target teammate name")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--stdin", "read interrupt message body from stdin")
         .option("--text-file <path>", "read interrupt message body from file")
         .argument("[text]", "inline interrupt message (otherwise use --stdin / --text-file)")
         .action(async (name, text, raw) => {
         const opts = raw;
         try {
-            await channelInterrupt(name, {
+            await teamworkSessionInterrupt(name, {
                 as: opts.as,
                 to: opts.to,
                 text,
@@ -161,25 +141,25 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("spawn <name>")
-        .description("Register a worker (claude/codex) into the channel — the worker stays idle until the first `channel send --to <worker>` arrives")
-        .option("--scope <scope>", "channel scope: project | global")
+        .description("Register a teammate process (claude/codex) in a Teamwork session — it stays idle until the first `teamwork send --to <teammate>` arrives")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--agent <agent-name>", "load .trellis/agents/<name>.md (sets default --provider / --model / system prompt)")
-        .option("--provider <provider>", "worker provider: claude | codex (overrides agent)")
-        .option("--as <name>", "worker name in the channel (default: <agent-name> if --agent is set)")
-        .option("--cwd <path>", "worker working directory (default: process cwd)")
+        .option("--provider <provider>", "teammate provider: claude | codex (overrides agent)")
+        .option("--as <name>", "teammate name in the Teamwork session (default: <agent-name> if --agent is set)")
+        .option("--cwd <path>", "teammate working directory (default: process cwd)")
         .option("--model <id>", "model override")
         .option("--resume <id>", "resume an existing session/thread id")
-        .option("--sandbox <mode>", "codex-only: worker sandbox mode: read-only | workspace-write | danger-full-access (default workspace-write)")
-        .option("--timeout <duration>", "auto-kill worker after this duration (subnode role default comes from config)")
-        .option("--warn-before <duration>", "emit supervisor_warning before timeout (subnode role default comes from config)")
-        .option("--file <path>", "include a file's content as context in the worker's system prompt (glob supported, repeatable)", (val, prev) => [...(prev ?? []), val], [])
+        .option("--sandbox <mode>", "codex-only: teammate sandbox mode: read-only | workspace-write | danger-full-access (default workspace-write)")
+        .option("--timeout <duration>", "auto-kill teammate process after this duration (e.g. 30m, 1h, 7200s)")
+        .option("--warn-before <duration>", "emit supervisor_warning before timeout (default 5m; 0ms disables)")
+        .option("--file <path>", "include a file's content as context in the teammate's system prompt (glob supported, repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .option("--jsonl <path>", "parse a Trellis jsonl manifest ({file, reason} per line) and include each referenced file (repeatable)", (val, prev) => [...(prev ?? []), val], [])
-        .option("--by <agent>", "identity recorded as the spawn author (defaults to TRELLIS_CHANNEL_AS env or 'main')")
-        .option("--inbox-policy <policy>", "worker inbox delivery policy: explicitOnly | broadcastAndExplicit (default explicitOnly)")
-        .option("--idle-timeout <duration>", "OOM-guard idle-cleanup TTL (subnode role default comes from config)")
-        .option("--max-live-workers <n>", "spawn-time live-worker budget (subnode role default comes from config)", parseNonNegativeInteger)
+        .option("--by <agent>", "identity recorded as the spawn author (defaults to TRELLIS_TEAMWORK_AS env or 'main')")
+        .option("--inbox-policy <policy>", "teammate inbox delivery policy: explicitOnly | broadcastAndExplicit (default explicitOnly)")
+        .option("--idle-timeout <duration>", "OOM-guard idle-cleanup TTL for this teammate (default 5m; 0 disables)")
+        .option("--max-live-teammates <n>", "spawn-time live-teammate budget for this project/scope (default 6; 0 disables)", parseNonNegativeInteger)
         .action(async (name, raw) => {
         const opts = raw;
         if (opts.provider !== undefined && !isProvider(opts.provider)) {
@@ -188,7 +168,7 @@ export function registerChannelCommand(program) {
         }
         try {
             const sandbox = parseCodexSandboxMode(opts.sandbox);
-            await channelSpawn(name, {
+            await teamworkSessionSpawn(name, {
                 agent: opts.agent,
                 provider: opts.provider,
                 as: opts.as,
@@ -204,7 +184,7 @@ export function registerChannelCommand(program) {
                 scope: opts.scope,
                 inboxPolicy: parseInboxPolicy(opts.inboxPolicy),
                 idleTimeoutMs: parseDuration(opts.idleTimeout),
-                maxLiveWorkers: opts.maxLiveWorkers,
+                maxLiveWorkers: opts.maxLiveTeammates,
             });
         }
         catch (err) {
@@ -212,38 +192,32 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
-        .command("workers <name>")
-        .description("Show durable worker lifecycle projections for a channel")
-        .option("--scope <scope>", "channel scope: project | global")
-        .option("--project-key <key>", "project bucket containing the channel (project scope only)")
-        .option("--include-terminal", "include done, error, killed, and crashed workers")
-        .option("--json", "print the complete worker projection as JSON")
-        .action(async (name, raw) => {
-        const opts = raw;
+    teamwork
+        .command("batch <plan>")
+        .description("Submit one frozen Teamwork plan; requires an installed host adapter")
+        .action(async (_planPath) => {
         try {
-            await channelWorkers(name, opts);
+            throw new Error("no verified teammate host adapter is installed; batch dispatch refused before writing coordination state");
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("run [name]")
-        .description("One-shot: create ephemeral channel, spawn worker, send prompt, wait done, print final answer, cleanup")
+        .description("One-shot: create an ephemeral Teamwork session, start a teammate, send the prompt, wait for completion, print the answer, and clean up")
         .option("--agent <agent-name>", "load .trellis/agents/<name>.md (sets default --provider / --as / system prompt)")
-        .option("--provider <provider>", "worker provider: claude | codex (overrides agent)")
-        .option("--as <name>", "worker name (default: agent name if --agent set)")
-        .option("--cwd <path>", "worker working directory")
+        .option("--provider <provider>", "teammate provider: claude | codex (overrides agent)")
+        .option("--as <name>", "teammate name (default: agent name if --agent set)")
+        .option("--cwd <path>", "teammate working directory")
         .option("--model <id>", "model override")
         .option("--file <path>", "include a file as context (glob supported, repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .option("--jsonl <path>", "parse a Trellis jsonl manifest and include each referenced file (repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .option("--message <text>", "inline prompt text")
         .option("--message-file <path>", "read prompt body from file")
         .option("--stdin", "read prompt body from stdin")
-        .option("--owner-session <id>", "opaque main Codex session owner (defaults to host session env)")
-        .option("--timeout <duration>", "max time to wait for done (e.g. 30s, 5m, 1h; default 5m, or channel.subnode.timeout for --agent subnode)")
+        .option("--timeout <duration>", "max time to wait for done (e.g. 30s, 5m, 1h; default 5m)")
         .action(async (name, raw) => {
         const opts = raw;
         if (opts.provider !== undefined && !isProvider(opts.provider)) {
@@ -251,7 +225,7 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
         try {
-            await channelRun({
+            await teamworkSessionRun({
                 name,
                 agent: opts.agent,
                 provider: opts.provider,
@@ -264,7 +238,6 @@ export function registerChannelCommand(program) {
                 textFile: opts.messageFile,
                 stdin: opts.stdin,
                 timeoutMs: parseDuration(opts.timeout),
-                ownerSession: opts.ownerSession,
             });
         }
         catch (err) {
@@ -272,34 +245,34 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("rm <name>")
-        .description("Kill workers and delete a channel directory entirely")
-        .option("--scope <scope>", "channel scope: project | global")
+        .description("Stop teammate processes and delete a Teamwork session entirely")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .action(async (name, raw) => {
         try {
-            await channelRm(name, raw);
+            await teamworkSessionRm(name, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("prune")
-        .description("Bulk-remove channels by criteria (defaults to dry-run preview)")
-        .option("--scope <scope>", "channel scope: project | global")
-        .option("--all", "remove all channels (except live ones and --keep)")
-        .option("--empty", "remove channels with no activity (only create event)")
-        .option("--idle <duration>", "remove channels whose last event is older than this (e.g. 1h, 7d)")
-        .option("--ephemeral", "remove only channels marked `--ephemeral` at create time")
+        .description("Bulk-remove Teamwork sessions by criteria (defaults to dry-run preview)")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
+        .option("--all", "remove all Teamwork sessions (except live ones and --keep)")
+        .option("--empty", "remove Teamwork sessions with no activity (only create event)")
+        .option("--idle <duration>", "remove sessions whose last event is older than this (e.g. 1h, 7d)")
+        .option("--ephemeral", "remove only sessions marked `--ephemeral` at create time")
         .option("--yes", "actually delete (default is dry-run)")
         .option("--dry-run", "show what would be removed without deleting", true)
-        .option("--keep <names>", "comma-separated channel names to keep regardless")
+        .option("--keep <names>", "comma-separated Teamwork session names to keep regardless")
         .action(async (raw) => {
         const opts = raw;
         try {
-            await channelPrune({
+            await teamworkSessionPrune({
                 all: opts.all,
                 empty: opts.empty,
                 idleMs: parseDuration(opts.idle),
@@ -315,29 +288,28 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("list")
-        .description("List channels in ~/.trellis/channels/ with worker / activity summary")
-        .option("--scope <scope>", "channel scope: project | global")
+        .description("List Teamwork Sessions in ~/.trellis/teamwork/ with teammate and activity summary")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--json", "emit JSON instead of a formatted table")
-        .option("--project <slug>", "filter channels whose `task` field contains this substring")
-        .option("--all", "include ephemeral channels (default: hide channels marked ephemeral)")
+        .option("--project <slug>", "filter sessions whose `task` field contains this substring")
+        .option("--all", "include ephemeral sessions (default: hide sessions marked ephemeral)")
         .option("--all-projects", "scan every project bucket (default: only the current cwd's project)")
-        .option("--owner-session <id>", "exactly match the immutable main Codex session owner")
         .action(async (raw) => {
         const opts = raw;
         try {
-            await channelList(opts);
+            await teamworkSessionList(opts);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("messages <name>")
-        .description("View messages and events in the channel")
-        .option("--scope <scope>", "channel scope: project | global")
+        .description("View messages and events in a Teamwork session")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--raw", "print raw JSON (one event per line)")
         .option("--follow", "stream new events as they arrive (Ctrl-C to stop)")
         .option("--last <N>", "show only the last N matching events", (v) => Number.parseInt(v, 10))
@@ -351,7 +323,7 @@ export function registerChannelCommand(program) {
         .action(async (name, raw) => {
         const opts = raw;
         try {
-            await channelMessages(name, {
+            await teamworkSessionMessages(name, {
                 raw: opts.raw,
                 follow: opts.follow,
                 last: opts.last,
@@ -370,27 +342,27 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("kill <name>")
-        .description("Stop a worker in the channel (SIGTERM, or SIGKILL with --force)")
-        .requiredOption("--as <agent>", "worker agent name")
-        .option("--scope <scope>", "channel scope: project | global")
+        .description("Stop a teammate process in the Teamwork session (SIGTERM, or SIGKILL with --force)")
+        .requiredOption("--as <agent>", "teammate agent name")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--force", "skip graceful shutdown, send SIGKILL immediately")
         .action(async (name, raw) => {
         const opts = raw;
         try {
-            await channelKill(name, opts);
+            await teamworkSessionKill(name, opts);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("post <name> <action>")
-        .description("Append a structured thread event to a forum channel")
+        .description("Append a structured thread event to a Teamwork forum")
         .requiredOption("--as <agent>", "agent name posting")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--thread <key>", "thread key (required except opened)")
         .option("--title <text>", "thread title")
         .option("--text <text>", "event body")
@@ -403,11 +375,9 @@ export function registerChannelCommand(program) {
         .option("--summary <text>", "thread summary")
         .option("--context-file <absolute-path>", "absolute file path attached as thread context (repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .option("--context-raw <text>", "raw thread context text (repeatable)", (val, prev) => [...(prev ?? []), val], [])
-        .option("--linked-context-file <absolute-path>", "[deprecated alias for --context-file] absolute file path (repeatable)", (val, prev) => [...(prev ?? []), val], [])
-        .option("--linked-context-raw <text>", "[deprecated alias for --context-raw] raw context text (repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .action(async (name, action, raw) => {
         try {
-            await channelThreadPost(name, {
+            await teamworkSessionThreadPost(name, {
                 ...raw,
                 action,
             });
@@ -417,32 +387,32 @@ export function registerChannelCommand(program) {
             process.exit(1);
         }
     });
-    channel
+    teamwork
         .command("forum <name>")
-        .description("List threads in a forum channel")
-        .option("--scope <scope>", "channel scope: project | global")
+        .description("List threads in a Teamwork forum")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--status <status>", "filter by thread status")
         .option("--raw", "print raw reduced thread JSON")
         .action(async (name, raw) => {
         try {
-            await channelForumList(name, raw);
+            await teamworkSessionForumList(name, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    const thread = channel
+    const thread = teamwork
         .command("thread")
         .description("Show or mutate one thread timeline");
     thread
-        .argument("<name>", "channel name")
+        .argument("<name>", "Teamwork session name")
         .argument("<thread>", "thread key")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .option("--raw", "print raw thread events")
         .action(async (name, threadKey, raw) => {
         try {
-            await channelThreadShow(name, threadKey, raw);
+            await teamworkSessionThreadShow(name, threadKey, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
@@ -451,33 +421,33 @@ export function registerChannelCommand(program) {
     });
     thread
         .command("rename <name> <oldThread> <newThread>")
-        .description("Rename a thread inside a forum channel")
+        .description("Rename a thread inside a Teamwork forum")
         .requiredOption("--as <agent>", "agent name")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .action(async (name, oldThread, newThread, raw) => {
         const opts = raw;
         try {
-            await channelThreadRename(name, oldThread, newThread, opts);
+            await teamworkSessionThreadRename(name, oldThread, newThread, opts);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    const context = channel
+    const context = teamwork
         .command("context")
-        .description("Manage channel-level or thread-level context entries");
+        .description("Manage Teamwork session-level or thread-level context entries");
     const addContextOptions = (cmd) => cmd
         .option("--as <agent>", "agent name", "main")
-        .option("--scope <scope>", "channel scope: project | global")
-        .option("--thread <key>", "mutate thread-level context instead of channel-level")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
+        .option("--thread <key>", "mutate thread-level context instead of Teamwork session-level")
         .option("--file <absolute-path>", "absolute file path (repeatable)", (val, prev) => [...(prev ?? []), val], [])
         .option("--raw <text>", "raw text entry (repeatable)", (val, prev) => [...(prev ?? []), val], []);
     addContextOptions(context.command("add <name>"))
         .description("Add context entries")
         .action(async (name, raw) => {
         try {
-            await channelContextAdd(name, raw);
+            await teamworkSessionContextAdd(name, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
@@ -488,7 +458,7 @@ export function registerChannelCommand(program) {
         .description("Delete context entries")
         .action(async (name, raw) => {
         try {
-            await channelContextDelete(name, raw);
+            await teamworkSessionContextDelete(name, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
@@ -498,31 +468,31 @@ export function registerChannelCommand(program) {
     context
         .command("list <name>")
         .description("List projected current context entries")
-        .option("--scope <scope>", "channel scope: project | global")
-        .option("--thread <key>", "show thread-level context instead of channel-level")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
+        .option("--thread <key>", "show thread-level context instead of Teamwork session-level")
         .option("--raw", "print one context entry JSON per line")
         .action(async (name, raw) => {
         try {
-            await channelContextList(name, raw);
+            await teamworkSessionContextList(name, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    const title = channel
+    const title = teamwork
         .command("title")
-        .description("Set or clear the channel display title");
+        .description("Set or clear the Teamwork session title");
     title
         .command("set <name>")
-        .description("Set the channel display title")
+        .description("Set the Teamwork session title")
         .option("--as <agent>", "agent name", "main")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .requiredOption("--title <text>", "display title")
         .action(async (name, raw) => {
         const opts = raw;
         try {
-            await channelTitleSet(name, opts);
+            await teamworkSessionTitleSet(name, opts);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
@@ -531,25 +501,25 @@ export function registerChannelCommand(program) {
     });
     title
         .command("clear <name>")
-        .description("Clear the channel display title")
+        .description("Clear the Teamwork session title")
         .option("--as <agent>", "agent name", "main")
-        .option("--scope <scope>", "channel scope: project | global")
+        .option("--scope <scope>", "Teamwork session scope: project | global")
         .action(async (name, raw) => {
         try {
-            await channelTitleClear(name, raw);
+            await teamworkSessionTitleClear(name, raw);
         }
         catch (err) {
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : err);
             process.exit(1);
         }
     });
-    // Hidden: supervisor entry point invoked by `channel spawn` via fork.
-    channel
-        .command("__supervisor <channel> <worker> <config>")
+    // Hidden: supervisor entry point invoked by `teamwork spawn` via fork.
+    teamwork
+        .command("__supervisor <teamwork-session> <teammate> <config>")
         .description("[internal] supervisor process entry point — do not invoke directly")
-        .action(async (channelName, worker, configPath) => {
+        .action(async (sessionId, teammateName, configPath) => {
         try {
-            await runSupervisor(channelName, worker, configPath);
+            await runSupervisor(sessionId, teammateName, configPath);
         }
         catch (err) {
             console.error(chalk.red("Supervisor error:"), err instanceof Error ? err.message : err);
@@ -557,9 +527,9 @@ export function registerChannelCommand(program) {
         }
     });
     // Dev-only: feed a recorded stream-json / wire trace through the matching
-    // adapter and print the resulting channel events. Used during adapter
+    // adapter and print the resulting Teamwork events. Used during adapter
     // development to verify against real-CLI fixtures.
-    channel
+    teamwork
         .command("__parse-trace <adapter> <file>")
         .description("[dev] Run a recorded trace through the parser and print events")
         .action((adapter, file) => {