@teamclaws/teamclaw 2026.3.24-6 → 2026.3.24-7

package/cli.mjs

@@ -26,7 +26,7 @@ const DEFAULT_TEAM_NAME = "default";
 const DEFAULT_TASK_TIMEOUT_MS = 1_800_000;
 const DEFAULT_AGENT_TIMEOUT_SECONDS = 2_400;
 const DEFAULT_LOCAL_ROLES = ["architect", "developer", "qa"];
-const DEFAULT_PROVISIONING_ROLES = ["architect", "developer", "qa"];
+const LEGACY_DEFAULT_PROVISIONING_ROLES = ["architect", "developer", "qa"];
 
 const ROLE_OPTIONS = [
   { value: "pm", label: "Product Manager" },
@@ -347,6 +347,27 @@ function dedupeStrings(values) {
   return Array.from(new Set(values.filter((value) => typeof value === "string" && value.trim()).map((value) => value.trim())));
 }
 
+function hasSameStringSet(left, right) {
+  const normalizedLeft = dedupeStrings(left).slice().sort();
+  const normalizedRight = dedupeStrings(right).slice().sort();
+  if (normalizedLeft.length !== normalizedRight.length) {
+    return false;
+  }
+  return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+
+function normalizeConfiguredRoleList(raw) {
+  return Array.isArray(raw) ? dedupeStrings(raw) : [];
+}
+
+function resolveDefaultProvisioningRoles(existingTeamClaw) {
+  const existingRoles = normalizeConfiguredRoleList(existingTeamClaw.workerProvisioningRoles);
+  if (existingRoles.length === 0) {
+    return [];
+  }
+  return hasSameStringSet(existingRoles, LEGACY_DEFAULT_PROVISIONING_ROLES) ? [] : existingRoles;
+}
+
 function extractModelOptions(config) {
   const currentModel = getCurrentModel(config);
   const models = [];
@@ -553,6 +574,28 @@ async function promptRoleList(prompter, message, defaultRoles) {
   return parseRoleList(raw).values;
 }
 
+async function promptOptionalRoleList(prompter, message, defaultRoles) {
+  const defaultValue = defaultRoles.join(",");
+  if (!prompter.yes) {
+    console.log(
+      `Available roles: ${ROLE_OPTIONS.map((option) => `${option.value} (${option.label})`).join(", ")}. Leave empty to allow all roles.`,
+    );
+  }
+  const raw = await prompter.text({
+    message,
+    defaultValue,
+    allowEmpty: true,
+    validate: (value) => {
+      const parsed = parseRoleList(value);
+      if (parsed.invalid.length > 0) {
+        return `Unknown role ids: ${parsed.invalid.join(", ")}`;
+      }
+      return "";
+    },
+  });
+  return parseRoleList(raw).values;
+}
+
 function buildStartCommand(configPath) {
   const defaultPath = resolveDefaultOpenClawConfigPath();
   if (path.resolve(configPath) === path.resolve(defaultPath)) {
@@ -572,6 +615,16 @@ function isControllerInstallMode(installMode) {
   return installMode !== "worker";
 }
 
+function isOnDemandControllerInstallMode(installMode) {
+  return installMode === "controller-process" || installMode === "controller-docker" || installMode === "controller-kubernetes";
+}
+
+function describeProvisioningRoles(roles) {
+  return Array.isArray(roles) && roles.length > 0
+    ? roles.join(", ")
+    : "all TeamClaw roles (controller decides at runtime)";
+}
+
 function getLocalUiUrl(port) {
   return `http://127.0.0.1:${port}/ui`;
 }
@@ -1097,12 +1150,10 @@ async function collectInstallChoices(configPath, config, prompter) {
     };
   }
 
-  const provisioningRoles = await promptRoleList(
+  const provisioningRoles = await promptOptionalRoleList(
     prompter,
-    "On-demand roles to launch (comma-separated)",
-    Array.isArray(existingTeamClaw.workerProvisioningRoles) && existingTeamClaw.workerProvisioningRoles.length > 0
-      ? existingTeamClaw.workerProvisioningRoles
-      : DEFAULT_PROVISIONING_ROLES,
+    "On-demand roles to allow (comma-separated, leave empty for all roles)",
+    resolveDefaultProvisioningRoles(existingTeamClaw),
   );
   const maxPerRole = await prompter.number({
     message: "Maximum on-demand workers per role",
@@ -1469,6 +1520,9 @@ function buildSummaryLines(params) {
   if (params.choices.installMode === "controller-docker" || params.choices.installMode === "controller-kubernetes") {
     lines.push(`Provisioning image: ${params.choices.workerImage}`);
   }
+  if (isOnDemandControllerInstallMode(params.choices.installMode)) {
+    lines.push(`On-demand roles: ${describeProvisioningRoles(params.choices.provisioningRoles)}`);
+  }
   if (params.choices.installMode === "controller-docker" && params.choices.dockerWorkspaceVolume) {
     lines.push(`Docker workspace volume: ${params.choices.dockerWorkspaceVolume}`);
   }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "teamclaw",
   "name": "TeamClaw",
   "description": "Virtual team collaboration - multiple OpenClaw instances form a virtual software company with role-based task routing.",
-  "version": "2026.3.24-6",
+  "version": "2026.3.24-7",
   "uiHints": {
     "mode": {
       "label": "Mode",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamclaws/teamclaw",
-  "version": "2026.3.24-6",
+  "version": "2026.3.24-7",
   "description": "OpenClaw virtual software team orchestration plugin",
   "private": false,
   "keywords": [

package/src/controller/controller-capacity.ts

@@ -0,0 +1,23 @@
+import type { PluginConfig, TeamState } from "../types.js";
+
+export function hasOnDemandWorkerProvisioning(
+  config: Pick<PluginConfig, "workerProvisioningType">,
+): boolean {
+  return config.workerProvisioningType !== "none";
+}
+
+export function shouldBlockControllerWithoutWorkers(
+  config: Pick<PluginConfig, "workerProvisioningType">,
+  state: TeamState | null,
+): boolean {
+  return !!state && Object.keys(state.workers).length === 0 && !hasOnDemandWorkerProvisioning(config);
+}
+
+export function buildControllerNoWorkersMessage(): string {
+  return [
+    "No TeamClaw workers are registered and on-demand provisioning is disabled.",
+    "You may analyze the requirement and identify the roles that would be needed,",
+    "but do not create TeamClaw tasks and do not do the worker-role work yourself.",
+    "Ask the human to bring workers online or enable process/docker/kubernetes provisioning first.",
+  ].join(" ");
+}

package/src/controller/controller-tools.ts

@@ -1,5 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { PluginConfig, TaskInfo, TeamState } from "../types.js";
+import { buildControllerNoWorkersMessage, hasOnDemandWorkerProvisioning, shouldBlockControllerWithoutWorkers } from "./controller-capacity.js";
 
 export type ControllerToolsDeps = {
   config: PluginConfig;
@@ -46,6 +47,16 @@ export function createControllerTools(deps: ControllerToolsDeps) {
           return { content: [{ type: "text" as const, text: "title is required." }] };
         }
 
+        const state = getTeamState();
+        if (shouldBlockControllerWithoutWorkers(config, state)) {
+          return {
+            content: [{
+              type: "text" as const,
+              text: `${buildControllerNoWorkersMessage()} Stop after reporting this block to the human.`,
+            }],
+          };
+        }
+
         const blocker = detectExecutionReadyBlocker(description);
         if (blocker) {
           return {
@@ -80,7 +91,9 @@ export function createControllerTools(deps: ControllerToolsDeps) {
           const assigned = task.assignedWorkerId
             ? ` -> assigned to ${task.assignedWorkerId}`
             : task.status === "pending"
-              ? " (pending - no available worker)"
+              ? hasOnDemandWorkerProvisioning(config)
+                ? " (pending - waiting for worker provisioning or an available worker)"
+                : " (pending - no registered/available worker)"
               : "";
           const recommended = Array.isArray(task.recommendedSkills) && task.recommendedSkills.length > 0
             ? ` | skills: ${task.recommendedSkills.join(", ")}`

package/src/controller/http-server.ts

@@ -39,6 +39,7 @@ import { MessageRouter } from "./message-router.js";
 import { TeamWebSocketServer } from "./websocket.js";
 import type { WorkerProvisioningManager } from "./worker-provisioning.js";
 import { createControllerPromptInjector } from "./prompt-injector.js";
+import { buildControllerNoWorkersMessage, shouldBlockControllerWithoutWorkers } from "./controller-capacity.js";
 
 export type ControllerHttpDeps = {
   config: PluginConfig;
@@ -1475,6 +1476,10 @@ async function handleRequest(
       sendError(res, 400, "title is required");
       return;
     }
+    if (createdBy === "controller" && shouldBlockControllerWithoutWorkers(deps.config, getTeamState())) {
+      sendError(res, 409, buildControllerNoWorkersMessage());
+      return;
+    }
 
     const taskId = generateId();
     const now = Date.now();

package/src/controller/prompt-injector.ts

@@ -1,5 +1,6 @@
 import type { PluginConfig, TeamState } from "../types.js";
 import { ROLES } from "../roles.js";
+import { hasOnDemandWorkerProvisioning, shouldBlockControllerWithoutWorkers } from "./controller-capacity.js";
 
 const TEAMCLAW_ROLE_IDS_TEXT = [
   "pm",
@@ -47,7 +48,14 @@ export function createControllerPromptInjector(deps: ControllerPromptDeps) {
     if (!state) {
       parts.push("- Team state is not loaded yet; treat this as a fresh controller intake and establish execution-ready tasks from the human requirement.");
     } else if (workers.length === 0) {
-      parts.push("- No workers registered yet");
+      if (shouldBlockControllerWithoutWorkers(deps.config, state)) {
+        parts.push("- No workers are registered and on-demand provisioning is disabled.");
+        parts.push("- Blocking rule: you may analyze the requirement and identify the needed roles, but do not create TeamClaw tasks yet.");
+        parts.push("- Do not start doing the worker-role work yourself. Tell the human to bring workers online or enable process/docker/kubernetes provisioning first.");
+      } else {
+        parts.push("- No workers are registered yet, but on-demand provisioning is enabled.");
+        parts.push("- You may still create execution-ready TeamClaw tasks for the required roles; the controller will provision workers on demand.");
+      }
     } else {
       for (const w of workers) {
         const roleDef = ROLES.find((r) => r.id === w.role);
@@ -86,6 +94,13 @@ export function createControllerPromptInjector(deps: ControllerPromptDeps) {
       parts.push(`- ${role.icon} ${role.label}: ${role.description}.${skillLine}`);
     }
 
+    parts.push("");
+    parts.push("## Controller Workflow");
+    parts.push("- First determine which TeamClaw roles are needed for the human requirement.");
+    parts.push("- Then translate the requirement into the minimum execution-ready TeamClaw tasks owned by those roles.");
+    parts.push("- TeamClaw workers, not the controller, do the specialist work in the shared repo/workspace.");
+    parts.push("- After workers report progress, results, or handoffs, create only the next tasks whose prerequisites are now satisfied.");
+
     parts.push("");
     parts.push("## Requirement Intake Rules");
     parts.push("- Human messages are the initial requirement, not an already-decomposed task tree.");
@@ -111,6 +126,13 @@ export function createControllerPromptInjector(deps: ControllerPromptDeps) {
     parts.push("- Do not let a worker task turn itself into a controller/coordinator workflow.");
     parts.push("- If the correct role is busy, prefer waiting, messaging, or explicit reassignment over routing core work to an unrelated role.");
     parts.push("- If a task is blocked by missing information, keep it in the clarification queue until the human answers; do not guess on the user's behalf.");
+    parts.push("- You are never a substitute worker. Do not personally perform architecture, implementation, QA, release, infra, design, marketing, research, or other specialist work.");
+    parts.push("- Your own reply must stay at the orchestration layer: clarification, role selection, task decomposition, assignment decisions, and concise status updates.");
+    if (hasOnDemandWorkerProvisioning(deps.config)) {
+      parts.push("- If no workers are currently registered but on-demand provisioning is enabled, you may still create execution-ready tasks so the required roles can be provisioned.");
+    } else {
+      parts.push("- If no workers are registered, you may mention which roles would be needed, but stop there and report the worker-capacity block to the human.");
+    }
     parts.push("- Use the controller itself for requirement analysis; use the PM role only for PM-owned deliverables after intake is clear.");
     parts.push(`- Use exact TeamClaw role IDs only: ${TEAMCLAW_ROLE_IDS_TEXT}.`);