@teamclaws/teamclaw 2026.3.26-2 → 2026.4.2-1

package/index.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import { definePluginEntry, type OpenClawPluginApi } from "./api.js";
 import { parsePluginConfig } from "./src/types.js";
 import type { TaskAssignmentPayload, TaskExecutionEventInput, TeamState, WorkerIdentity } from "./src/types.js";
@@ -9,10 +11,10 @@ import { createWorkerPromptInjector } from "./src/worker/prompt-injector.js";
 import { createWorkerTools } from "./src/worker/tools.js";
 import { MessageQueue } from "./src/worker/message-queue.js";
 import { createControllerService } from "./src/controller/controller-service.js";
-import { LocalWorkerManager } from "./src/controller/local-worker-manager.js";
 import { createControllerPromptInjector } from "./src/controller/prompt-injector.js";
 import { createControllerTools } from "./src/controller/controller-tools.js";
 import { publishWorkerRepo, syncWorkerRepo } from "./src/git-collaboration.js";
+import { resolveTeamClawProjectsDir } from "./src/openclaw-workspace.js";
 import { installRecommendedSkills } from "./src/worker/skill-installer.js";
 
 export default definePluginEntry({
@@ -34,37 +36,29 @@ export default definePluginEntry({
 
 function registerController(api: OpenClawPluginApi, config: ReturnType<typeof parsePluginConfig>) {
   const logger = api.logger;
-  const localWorkerManager = new LocalWorkerManager({
-    config,
-    logger,
-    runtime: api.runtime,
-  });
   let getControllerTeamState = (): TeamState | null => null;
+  let controllerUrl = `http://127.0.0.1:${config.port}`;
+  let kickoffHandler: ((candidateRoles: import("./src/types.js").RoleId[], complexity: "simple" | "medium" | "complex", requirement: string) => Promise<{ assessments: import("./src/types.js").KickoffAssessment[]; summary: string }>) | undefined;
 
   // Service (starts HTTP server + mDNS + WebSocket)
   api.registerService(createControllerService({
     config,
     logger,
     runtime: api.runtime,
-    localWorkerManager,
     onTeamStateAvailable: (getter) => {
       getControllerTeamState = getter;
     },
+    onActualPort: (port) => {
+      controllerUrl = `http://127.0.0.1:${port}`;
+    },
+    onKickoffHandlerAvailable: (handler) => {
+      kickoffHandler = handler;
+      logger.info("TeamClaw: kickoff handler registered successfully");
+    },
   }));
 
   // Prompt injection
   api.on("before_prompt_build", async (_event: unknown, ctx: { sessionKey?: string | null }) => {
-    const localIdentity = localWorkerManager.getIdentityForSession(ctx.sessionKey);
-    const localMessageQueue = localWorkerManager.getMessageQueueForSession(ctx.sessionKey);
-    if (localIdentity && localMessageQueue) {
-      const injector = createWorkerPromptInjector(
-        { ...config, role: localIdentity.role },
-        () => localIdentity,
-        localMessageQueue,
-      );
-      return injector() ?? {};
-    }
-
     const state = getControllerTeamState() ?? await loadTeamState(config.teamName);
     const injector = createControllerPromptInjector({
       config,
@@ -74,21 +68,13 @@ function registerController(api: OpenClawPluginApi, config: ReturnType<typeof pa
   });
 
   // Tools - register all controller tools via factory returning an array
-  const controllerUrl = `http://localhost:${config.port}`;
   api.registerTool((ctx: { sessionKey?: string | null }) => {
-    const localIdentity = localWorkerManager.getIdentityForSession(ctx.sessionKey);
-    if (localIdentity) {
-      return createWorkerTools({
-        config: { ...config, role: localIdentity.role },
-        getIdentity: () => localIdentity,
-      });
-    }
-
     return createControllerTools({
       config,
       controllerUrl,
       getTeamState: getControllerTeamState,
       sessionKey: ctx.sessionKey ?? null,
+      getKickoffHandler: () => kickoffHandler,
     });
   });
 }
@@ -146,6 +132,41 @@ function registerWorker(api: OpenClawPluginApi, config: ReturnType<typeof parseP
     reportExecutionEvent,
   });
 
+  function resolveProjectSyncPaths(projectDir: string | undefined): { sharedProjectDir: string; localProjectDir: string } | null {
+    const normalizedProjectDir = projectDir?.trim();
+    const sharedWorkspaceOverride = process.env.TEAMCLAW_WORKSPACE_DIR?.trim();
+    if (!normalizedProjectDir || !sharedWorkspaceOverride) {
+      return null;
+    }
+
+    const sharedProjectDir = path.join(resolveTeamClawProjectsDir(), normalizedProjectDir);
+    const localEnv = { ...process.env };
+    delete localEnv.TEAMCLAW_WORKSPACE_DIR;
+    const localProjectDir = path.join(resolveTeamClawProjectsDir(localEnv), normalizedProjectDir);
+    if (sharedProjectDir === localProjectDir) {
+      return null;
+    }
+    return { sharedProjectDir, localProjectDir };
+  }
+
+  async function pathExists(targetPath: string): Promise<boolean> {
+    try {
+      await fs.access(targetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function syncProjectDir(sourceDir: string, destinationDir: string): Promise<boolean> {
+    if (!await pathExists(sourceDir)) {
+      return false;
+    }
+    await fs.mkdir(path.dirname(destinationDir), { recursive: true });
+    await fs.cp(sourceDir, destinationDir, { recursive: true, force: true });
+    return true;
+  }
+
   // Service
   api.registerService(
     createWorkerService({
@@ -176,6 +197,20 @@ function registerWorker(api: OpenClawPluginApi, config: ReturnType<typeof parseP
           }
         }
 
+        const syncPaths = resolveProjectSyncPaths(assignment.projectDir);
+        if (syncPaths) {
+          const restored = await syncProjectDir(syncPaths.sharedProjectDir, syncPaths.localProjectDir);
+          if (restored) {
+            await reportExecutionEvent(assignment.taskId, {
+              type: "lifecycle",
+              phase: "project_sync_restored",
+              source: "worker",
+              status: "running",
+              message: `Restored shared project files into the worker runtime from ${syncPaths.sharedProjectDir}.`,
+            });
+          }
+        }
+
         if (!assignment.repo?.enabled || !controllerUrl) {
           return;
         }
@@ -210,6 +245,20 @@ function registerWorker(api: OpenClawPluginApi, config: ReturnType<typeof parseP
         }
       },
       publishTaskAssignment: async (assignment) => {
+        const syncPaths = resolveProjectSyncPaths(assignment.projectDir);
+        if (syncPaths) {
+          const published = await syncProjectDir(syncPaths.localProjectDir, syncPaths.sharedProjectDir);
+          if (published) {
+            await reportExecutionEvent(assignment.taskId, {
+              type: "lifecycle",
+              phase: "project_sync_published",
+              source: "worker",
+              status: "running",
+              message: `Published worker runtime project files back to the shared workspace at ${syncPaths.sharedProjectDir}.`,
+            });
+          }
+        }
+
         const controllerUrl = currentControllerUrl || config.controllerUrl.trim();
         if (!assignment.repo?.enabled || !controllerUrl) {
           return;

package/openclaw.plugin.json

@@ -2,7 +2,10 @@
   "id": "teamclaw",
   "name": "TeamClaw",
   "description": "Virtual team collaboration - multiple OpenClaw instances form a virtual software company with role-based task routing.",
-  "version": "2026.3.26-2",
+  "version": "2026.4.2-1",
+  "skills": [
+    "./skills"
+  ],
   "uiHints": {
     "mode": {
       "label": "Mode",
@@ -29,8 +32,8 @@
       "help": "In milliseconds, minimum 1000"
     },
     "taskTimeoutMs": {
-      "label": "Task Timeout",
-      "help": "Maximum time to wait for a role task to finish before marking it failed (in milliseconds)"
+      "label": "Task Stall Threshold",
+      "help": "In milliseconds, how long TeamClaw waits without visible progress before probing the task instead of failing it"
     },
     "gitEnabled": {
       "label": "Git Collaboration",
@@ -52,14 +55,22 @@
       "label": "Git Author Email",
       "help": "Author email for TeamClaw-managed workspace commits"
     },
-    "localRoles": {
-      "label": "Local Roles",
-      "help": "Controller mode only: run these roles as local virtual workers inside the same OpenClaw instance"
+    "agentIsolationMode": {
+      "label": "Agent Isolation Mode",
+      "help": "Use a dedicated TeamClaw agent/workspace by default, or the legacy shared main-agent mode"
+    },
+    "processModel": {
+      "label": "Process Model",
+      "help": "TeamClaw runs workers as separate gateway processes"
     },
     "workerProvisioningType": {
       "label": "On-demand Worker Provider",
       "help": "Launch missing workers on demand using process, Docker, or Kubernetes"
     },
+    "workerProvisioningDisabled": {
+      "label": "Disable On-demand Workers",
+      "help": "Force TeamClaw to keep worker provisioning off even for same-host local controllers"
+    },
     "workerProvisioningControllerUrl": {
       "label": "Provisioned Worker Controller URL",
       "help": "URL that launched workers use to call back into the controller"
@@ -124,6 +135,10 @@
       "label": "Kubernetes Service Account",
       "help": "Optional service account for launched worker pods"
     },
+    "workerProvisioningKubernetesImagePullSecrets": {
+      "label": "Kubernetes Image Pull Secrets",
+      "help": "Optional secret names added to launched worker pods so they can pull private images"
+    },
     "workerProvisioningKubernetesWorkspacePersistentVolumeClaim": {
       "label": "Kubernetes Workspace PVC",
       "help": "Optional PVC mounted as the persistent workspace root for launched worker pods"
@@ -166,7 +181,7 @@
       },
       "teamName": {
         "type": "string",
-        "default": "default",
+        "default": "TeamClaw",
         "description": "Team name for mDNS identification"
       },
       "heartbeatIntervalMs": {
@@ -177,7 +192,7 @@
       "taskTimeoutMs": {
         "type": "number",
         "default": 1800000,
-        "description": "Maximum time in milliseconds to wait for a role task to finish"
+        "description": "Inactivity threshold in milliseconds before TeamClaw probes a stalled role task instead of failing it"
       },
       "gitEnabled": {
         "type": "boolean",
@@ -204,25 +219,22 @@
         "default": "teamclaw@local",
         "description": "Git author email used for TeamClaw-managed workspace commits"
       },
-      "localRoles": {
-        "type": "array",
-        "default": [],
-        "description": "Controller-local roles executed in this same OpenClaw instance",
-        "items": {
-          "type": "string",
-          "enum": [
-            "pm",
-            "architect",
-            "developer",
-            "qa",
-            "release-engineer",
-            "infra-engineer",
-            "devops",
-            "security-engineer",
-            "designer",
-            "marketing"
-          ]
-        }
+      "agentIsolationMode": {
+        "type": "string",
+        "enum": [
+          "independent",
+          "main"
+        ],
+        "default": "independent",
+        "description": "Runtime isolation mode: dedicated TeamClaw agent/workspace, or legacy main-agent shared mode"
+      },
+      "processModel": {
+        "type": "string",
+        "enum": [
+          "multi"
+        ],
+        "default": "multi",
+        "description": "Worker execution model: TeamClaw runs workers as separate gateway processes"
       },
       "workerProvisioningType": {
         "type": "string",
@@ -235,6 +247,11 @@
         "default": "none",
         "description": "Controller-only on-demand worker launch backend"
       },
+      "workerProvisioningDisabled": {
+        "type": "boolean",
+        "default": false,
+        "description": "Explicitly disable controller-managed on-demand workers even when TeamClaw would normally default to same-host process provisioning"
+      },
       "workerProvisioningControllerUrl": {
         "type": "string",
         "default": "",
@@ -267,7 +284,7 @@
       },
       "workerProvisioningMaxPerRole": {
         "type": "number",
-        "default": 1,
+        "default": 3,
         "description": "Maximum on-demand workers to launch per role"
       },
       "workerProvisioningIdleTtlMs": {
@@ -339,6 +356,14 @@
         "default": "",
         "description": "Optional service account name for launched worker pods"
       },
+      "workerProvisioningKubernetesImagePullSecrets": {
+        "type": "array",
+        "default": [],
+        "description": "Optional image pull secret names added to launched worker pods",
+        "items": {
+          "type": "string"
+        }
+      },
       "workerProvisioningKubernetesWorkspacePersistentVolumeClaim": {
         "type": "string",
         "default": "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamclaws/teamclaw",
-  "version": "2026.3.26-2",
+  "version": "2026.4.2-1",
   "description": "OpenClaw virtual software team orchestration plugin",
   "private": false,
   "keywords": [
@@ -36,12 +36,15 @@
     "cli.mjs",
     "index.ts",
     "openclaw.plugin.json",
+    "skills/",
     "src/",
     "tsconfig.json"
   ],
   "scripts": {
+    "manifest:sync": "cd .. && node scripts/sync-teamclaw-plugin-manifest.mjs src",
     "pack:dry-run": "npm pack --dry-run --json --ignore-scripts",
-    "release:check": "node ../scripts/teamclaw-package-check.mjs src"
+    "release:check": "cd .. && node scripts/teamclaw-package-check.mjs src",
+    "release:clawhub:dry-run": "cd .. && bash scripts/teamclaw-clawhub-release.sh --dry-run"
   },
   "dependencies": {
     "@sinclair/typebox": "0.34.48",

package/skills/teamclaw/SKILL.md

@@ -0,0 +1,213 @@
+---
+name: teamclaw
+description: >
+  Orchestrate a virtual AI software team to build features, fix bugs, or complete any software task.
+  Use when the user wants to delegate work to a multi-role team (developer, architect, QA, etc.),
+  check team progress, review task results, or answer worker clarifications.
+  Triggers: "build me ...", "create a ...", "team status", "assign to team", "teamclaw",
+  "have the team ...", "delegate this to ...", "what are the workers doing".
+version: 1.0.0
+metadata:
+  openclaw:
+    author: TeamClaws
+    homepage: https://github.com/topcheer/teamclaw
+    links:
+      homepage: https://github.com/topcheer/teamclaw
+      repository: https://github.com/topcheer/teamclaw
+      documentation: https://github.com/topcheer/teamclaw/blob/main/README.md
+      changelog: https://github.com/topcheer/teamclaw/releases
+---
+
+# TeamClaw — AI Team Orchestration
+
+Orchestrate a virtual software team through natural conversation. Submit requirements, monitor progress, review deliverables, and answer clarifications — all without leaving your chat.
+
+## When to Use This Skill
+
+Activate when the user:
+
+- Wants to **build, create, or implement** something (e.g., "build me a todo app", "create an auth system")
+- Asks to **delegate work** to a team (e.g., "have the team work on this", "assign this to the developer")
+- Wants to check **team status** (e.g., "what are the workers doing?", "show me task progress")
+- Needs to **review results** (e.g., "show me what the developer built", "check the QA report")
+- Has **pending clarifications** to answer (e.g., "are there questions from the team?")
+- Mentions **teamclaw** by name
+
+## Prerequisites
+
+TeamClaw must be running in controller mode. Detect the controller URL:
+
+```bash
+# Default controller URL
+TEAMCLAW_URL="http://127.0.0.1:9527"
+
+# Health check — verify the controller is running
+curl -sf "$TEAMCLAW_URL/api/v1/health"
+```
+
+If the health check fails, tell the user to start TeamClaw first (install the `teamclaw-setup` skill for guidance).
+
+## Core Workflow
+
+### 1. Submit a Requirement
+
+When the user describes what they want built, submit it to the controller intake:
+
+```bash
+curl -s -X POST "$TEAMCLAW_URL/api/v1/controller/intake" \
+  -H "Content-Type: application/json" \
+  -d '{"message": "<user requirement here>"}'
+```
+
+The controller will:
+1. Analyze the requirement
+2. Decompose it into tasks for appropriate roles (developer, architect, QA, etc.)
+3. Assign tasks to available workers
+4. Return a controller run with tracking info
+
+**Response fields:**
+- `controllerRun.id` — run identifier for tracking
+- `controllerRun.status` — `running`, `completed`, `failed`
+- `result` — the controller agent's orchestration output
+
+**Important:** The intake call may take 30-180 seconds as the controller agent plans and decomposes the work. Use `--max-time 300` with curl for large requirements.
+
+### 2. Monitor Progress
+
+#### Check team overview
+```bash
+curl -s "$TEAMCLAW_URL/api/v1/team/status"
+```
+
+Key response fields:
+- `workers` — map of all workers with their status (`idle`, `busy`, `offline`)
+- `tasks` — map of all tasks with status (`pending`, `assigned`, `in-progress`, `completed`, `failed`)
+- `pendingClarificationCount` — number of unanswered questions from workers
+- `controllerRuns` — orchestration run history
+
+#### List tasks
+```bash
+curl -s "$TEAMCLAW_URL/api/v1/tasks"
+```
+
+#### Get task details with execution history
+```bash
+curl -s "$TEAMCLAW_URL/api/v1/tasks/<taskId>/execution"
+```
+
+Returns the task with full execution log (lifecycle events, progress updates, errors).
+
+#### List workers
+```bash
+curl -s "$TEAMCLAW_URL/api/v1/workers"
+```
+
+### 3. Review Results
+
+When a task completes, its result contract contains structured deliverables:
+
+```bash
+# Get the task to see its resultContract
+curl -s "$TEAMCLAW_URL/api/v1/tasks/<taskId>"
+```
+
+The `resultContract` includes:
+- `summary` — what was accomplished
+- `deliverables[]` — list of files, notes, or artifacts produced
+- `discoveredPatterns[]` — patterns noticed during execution
+- `suggestedNextSteps[]` — recommended follow-up actions
+
+### 4. Handle Clarifications
+
+Workers may need clarification to proceed. Check and answer them:
+
+```bash
+# List pending clarifications
+curl -s "$TEAMCLAW_URL/api/v1/clarifications"
+
+# Answer a clarification
+curl -s -X POST "$TEAMCLAW_URL/api/v1/clarifications/<clarificationId>/answer" \
+  -H "Content-Type: application/json" \
+  -d '{"answer": "<your answer>", "answeredBy": "user"}'
+```
+
+### 5. Create Individual Tasks
+
+For fine-grained control, create tasks directly:
+
+```bash
+curl -s -X POST "$TEAMCLAW_URL/api/v1/tasks" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "title": "Implement user login",
+    "description": "Create a login form with email/password auth",
+    "priority": "high",
+    "assignedRole": "developer"
+  }'
+```
+
+Valid roles: `pm`, `architect`, `developer`, `qa`, `release-engineer`, `infra-engineer`, `devops`, `security-engineer`, `designer`, `marketing`.
+
+Valid priorities: `low`, `medium`, `high`.
+
+### 6. Send Messages to the Team
+
+```bash
+# Direct message to a role
+curl -s -X POST "$TEAMCLAW_URL/api/v1/messages/direct" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "from": "user",
+    "toRole": "developer",
+    "content": "Please also add input validation"
+  }'
+
+# Broadcast to all workers
+curl -s -X POST "$TEAMCLAW_URL/api/v1/messages/broadcast" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "from": "user",
+    "content": "Deadline moved up — prioritize core features"
+  }'
+```
+
+## Response Presentation
+
+When presenting results to the user:
+
+1. **After intake submission**: Summarize what the controller planned — how many tasks, which roles assigned, estimated workflow.
+
+2. **For status checks**: Show a concise table of workers and tasks:
+   ```
+   Workers: 3 active (developer: busy, qa: idle, architect: idle)
+   Tasks: 5 total (2 completed, 1 in-progress, 2 pending)
+   Clarifications: 1 pending
+   ```
+
+3. **For completed tasks**: Highlight the deliverables, key files changed, and suggested next steps.
+
+4. **For clarifications**: Present the question clearly and ask the user to provide an answer.
+
+## Web UI
+
+TeamClaw also provides a web dashboard for visual monitoring:
+
+```
+Open in browser: $TEAMCLAW_URL/ui
+```
+
+Mention this to users who prefer a visual overview.
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Health check fails | Ensure TeamClaw plugin is enabled in controller mode: `openclaw plugins list` |
+| No workers available | Check processModel config; single-process creates workers automatically |
+| Intake times out | Increase `taskTimeoutMs` in TeamClaw config; ensure AI model is responsive |
+| Task stuck in pending | No idle worker for the assigned role; check `GET /api/v1/workers` |
+| Clarification blocking | Answer pending clarifications via `POST /api/v1/clarifications/:id/answer` |
+
+## Read references for detailed API docs
+
+Read `references/api-quick-ref.md` for the complete endpoint reference when you need exact request/response formats.

package/skills/teamclaw/references/api-quick-ref.md

@@ -0,0 +1,117 @@
+# TeamClaw API Quick Reference
+
+## Controller URL
+
+Default: `http://127.0.0.1:9527`
+
+## Endpoints
+
+### Health & Status
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/v1/health` | Health check → `{"status":"ok"}` |
+| GET | `/api/v1/team/status` | Full team snapshot (workers, tasks, runs, clarifications) |
+| GET | `/api/v1/roles` | List all available roles |
+
+### Controller Orchestration
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/v1/controller/intake` | Submit requirement → auto-decompose into tasks |
+| GET | `/api/v1/controller/runs` | List orchestration runs |
+
+**Intake request:**
+```json
+{ "message": "Build a REST API for user management" }
+```
+
+**Intake response:**
+```json
+{
+  "controllerRun": { "id": "run-abc", "status": "completed", "source": "intake" },
+  "result": "Orchestration output text..."
+}
+```
+
+### Tasks
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/v1/tasks` | Create task |
+| GET | `/api/v1/tasks` | List all tasks |
+| GET | `/api/v1/tasks/:id` | Get task detail |
+| GET | `/api/v1/tasks/:id/execution` | Get task with execution events |
+| PATCH | `/api/v1/tasks/:id` | Update task (status, priority, progress) |
+| POST | `/api/v1/tasks/:id/assign` | Assign to worker/role |
+| POST | `/api/v1/tasks/:id/handoff` | Hand off to another role |
+| POST | `/api/v1/tasks/:id/result` | Submit result |
+
+**Create task:**
+```json
+{
+  "title": "Implement login form",
+  "description": "Email/password login with validation",
+  "priority": "high",
+  "assignedRole": "developer"
+}
+```
+
+**Task statuses:** `pending` → `assigned` → `in-progress` → `completed` | `failed` | `blocked`
+
+**Priorities:** `low`, `medium`, `high`
+
+**Roles:** `pm`, `architect`, `developer`, `qa`, `release-engineer`, `infra-engineer`, `devops`, `security-engineer`, `designer`, `marketing`
+
+### Workers
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/v1/workers` | List workers |
+| POST | `/api/v1/workers/register` | Register worker |
+| POST | `/api/v1/workers/:id/heartbeat` | Heartbeat |
+| DELETE | `/api/v1/workers/:id` | Remove worker |
+
+**Worker statuses:** `idle`, `busy`, `offline`
+
+**Transport types:** `http` (external or dynamically provisioned worker callback)
+
+### Messages
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/v1/messages/direct` | Send to specific role |
+| POST | `/api/v1/messages/broadcast` | Send to all workers |
+| POST | `/api/v1/messages/review-request` | Request review from role |
+| GET | `/api/v1/messages` | List messages (query: `limit`, `offset`) |
+
+**Direct message:**
+```json
+{ "from": "user", "toRole": "developer", "content": "Add input validation" }
+```
+
+### Clarifications
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/v1/clarifications` | List all (includes `pendingCount`) |
+| POST | `/api/v1/clarifications` | Request clarification |
+| POST | `/api/v1/clarifications/:id/answer` | Answer clarification |
+
+**Answer:**
+```json
+{ "answer": "Use PostgreSQL for the database", "answeredBy": "user" }
+```
+
+### Workspace
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/v1/workspace/tree` | Directory tree |
+| GET | `/api/v1/workspace/file?path=<path>` | File content |
+
+### Web UI
+
+| Path | Description |
+|------|-------------|
+| `/ui` | TeamClaw dashboard |