@teamclaws/teamclaw 2026.4.2-3 → 2026.4.2-5

package/README.md

@@ -71,6 +71,15 @@ For maintainers, TeamClaw now uses two release paths:
 1. **npm package** — published by GitHub Actions via `.github/workflows/teamclaw-plugin-npm-release.yml`
 2. **ClawHub code plugin + bundled skills** — published manually from the CLI
 
+The npm publish workflow runs automatically when:
+
+- a tag matching `v*` is pushed
+- or relevant package files change on `main` (`src/**`, `.github/workflows/teamclaw-plugin-npm-release.yml`, `scripts/sync-teamclaw-plugin-manifest.mjs`, `scripts/teamclaw-package-check.mjs`, `scripts/teamclaw-npm-publish.sh`)
+
+It also supports `workflow_dispatch` for a specific commit SHA on `main`.
+
+Before the first real npm publish, GitHub must already be configured for npm trusted publishing with the `npm-release` environment and this workflow file.
+
 Before either release path, sync and validate the generated plugin manifest:
 
 ```bash
@@ -101,7 +110,7 @@ For a first-time setup, the safest path is:
 2. Validate the workflow with a small smoke-test task
 3. Expand to external workers, Docker, or Kubernetes after the basics are working
 
-When on-demand provisioning is enabled, TeamClaw now treats controller startup as a readiness phase, not just a process-up check. During that warm-up, `/api/v1/health` returns a non-OK status until the controller has verified writable runtime paths and successfully brought the configured startup worker roles online.
+When on-demand provisioning is enabled, TeamClaw now treats controller startup as a readiness phase, not just a process-up check. During that warm-up, `/api/v1/health` returns a non-OK status until the controller has verified writable runtime paths and successfully brought the configured startup worker roles online. If `workerProvisioningRoles` is empty, startup readiness defaults to waiting for a warm `developer` worker.
 
 ## Documentation
 

package/cli.mjs

@@ -64,7 +64,7 @@ const INSTALL_MODE_OPTIONS = [
   {
     value: "controller-manual",
     label: "Local controller + default on-demand workers",
-    hint: "Lean same-host setup; TeamClaw launches local worker processes on demand with controller-decided defaults.",
+    hint: "Lean same-host setup; writes workerProvisioningRoles=[] and workerProvisioningMaxPerRole=1.",
   },
   {
     value: "controller-docker",
@@ -1363,7 +1363,7 @@ async function collectInstallChoices(configPath, config, prompter, options) {
 
   const provisioningRoles = await promptOptionalRoleList(
     prompter,
-    "Preferred on-demand roles (comma-separated, leave empty for controller-decided defaults)",
+    "Preferred on-demand roles (comma-separated, leave empty to keep workerProvisioningRoles empty and let startup readiness default to a warm developer worker)",
     resolveDefaultProvisioningRoles(existingTeamClaw),
   );
   const maxPerRole = await prompter.number({
@@ -1371,7 +1371,7 @@ async function collectInstallChoices(configPath, config, prompter, options) {
     defaultValue:
       typeof existingTeamClaw.workerProvisioningMaxPerRole === "number" && existingTeamClaw.workerProvisioningMaxPerRole >= 1
         ? existingTeamClaw.workerProvisioningMaxPerRole
-        : 2,
+        : 10,
     min: 1,
     max: 50,
   });
@@ -1677,7 +1677,7 @@ function applyInstallerChoices(config, choices, configPath) {
     teamclawConfig.workerProvisioningDisabled = true;
     teamclawConfig.workerProvisioningControllerUrl = "";
     teamclawConfig.workerProvisioningRoles = [];
-    teamclawConfig.workerProvisioningMaxPerRole = 1;
+    teamclawConfig.workerProvisioningMaxPerRole = 10;
     teamclawConfig.workerProvisioningImage = "";
     teamclawConfig.workerProvisioningPassEnv = [];
     teamclawConfig.workerProvisioningExtraEnv = {};
@@ -1697,7 +1697,7 @@ function applyInstallerChoices(config, choices, configPath) {
       teamclawConfig.workerProvisioningDisabled = false;
       teamclawConfig.workerProvisioningControllerUrl = "";
       teamclawConfig.workerProvisioningRoles = [];
-      teamclawConfig.workerProvisioningMaxPerRole = 1;
+      teamclawConfig.workerProvisioningMaxPerRole = 10;
       teamclawConfig.workerProvisioningImage = "";
       teamclawConfig.workerProvisioningPassEnv = [];
       teamclawConfig.workerProvisioningExtraEnv = {};

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.4.2-3",
+  "version": "2026.4.2-5",
   "skills": [
     "./skills"
   ],
@@ -260,7 +260,7 @@
       "workerProvisioningRoles": {
         "type": "array",
         "default": [],
-        "description": "Preferred on-demand roles; task-required roles can still launch automatically. Empty means controller-decided defaults across all roles",
+        "description": "Preferred on-demand roles; task-required roles can still launch automatically. Empty means no preferred startup role list, so startup readiness falls back to a warm developer worker",
         "items": {
           "type": "string",
           "enum": [

package/package.json

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

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

@@ -10,7 +10,7 @@ Default: `http://127.0.0.1:9527`
 
 | Method | Path | Description |
 |--------|------|-------------|
-| GET | `/api/v1/health` | Health check → `{"status":"ok"}` |
+| GET | `/api/v1/health` | Health/readiness check; may report a non-OK startup readiness state until required warm workers are online |
 | GET | `/api/v1/team/status` | Full team snapshot (workers, tasks, runs, clarifications) |
 | GET | `/api/v1/roles` | List all available roles |
 

package/skills/teamclaw-setup/references/install-modes.md

@@ -48,7 +48,7 @@ Minimal TeamClaw plugin block:
   "workerProvisioningType": "process",
   "workerProvisioningRoles": [],
   "workerProvisioningMinPerRole": 0,
-  "workerProvisioningMaxPerRole": 2,
+  "workerProvisioningMaxPerRole": 10,
   "workerProvisioningIdleTtlMs": 120000,
   "workerProvisioningStartupTimeoutMs": 120000
 }
@@ -56,6 +56,12 @@ Minimal TeamClaw plugin block:
 
 Use this first because it avoids multi-machine networking while still exercising the real controller, provisioned workers, UI, messages, clarifications, and git-backed workspace flow.
 
+If the user is specifically choosing install modes through the guided installer, remember the resulting config differs by mode:
+
+- `controller-manual` writes `workerProvisioningType: "process"` and `workerProvisioningRoles: []`, so startup readiness falls back to a warm `developer` worker
+- `controller-process` writes `workerProvisioningType: "process"` and uses the chosen roles/max-per-role
+- `worker` disables provisioning on that node
+
 ## 4. Worker-only topology
 
 Use this only when a controller already exists elsewhere:
@@ -83,7 +89,7 @@ Use this when the controller should launch same-machine workers only as needed:
   "teamName": "my-team",
   "workerProvisioningType": "process",
   "workerProvisioningMinPerRole": 0,
-  "workerProvisioningMaxPerRole": 2,
+  "workerProvisioningMaxPerRole": 10,
   "workerProvisioningIdleTtlMs": 120000,
   "workerProvisioningStartupTimeoutMs": 120000
 }
@@ -103,7 +109,7 @@ Use this when the user already has Docker and wants containerized workers:
   "workerProvisioningImage": "ghcr.io/topcheer/teamclaw-openclaw:latest",
   "workerProvisioningWorkspaceRoot": "/workspace-root",
   "workerProvisioningDockerWorkspaceVolume": "teamclaw-workspaces",
-  "workerProvisioningMaxPerRole": 3
+  "workerProvisioningMaxPerRole": 10
 }
 ```
 
@@ -126,7 +132,7 @@ Use this only when the user already runs the controller in or behind a reachable
   "workerProvisioningImage": "ghcr.io/topcheer/teamclaw-openclaw:latest",
   "workerProvisioningWorkspaceRoot": "/workspace-root",
   "workerProvisioningKubernetesWorkspacePersistentVolumeClaim": "teamclaw-workspace",
-  "workerProvisioningMaxPerRole": 2
+  "workerProvisioningMaxPerRole": 10
 }
 ```
 

package/skills/teamclaw-setup/references/validation-checklist.md

@@ -14,6 +14,8 @@ Expected shape:
 {"status":"ok","mode":"controller", ...}
 ```
 
+If on-demand provisioning is enabled, `/api/v1/health` can temporarily return a non-OK readiness state during warm-up. When `workerProvisioningRoles` is empty, readiness defaults to waiting for a warm `developer` worker.
+
 Also point them to:
 
 ```text
@@ -67,7 +69,7 @@ If OpenClaw times out first, users often think TeamClaw is broken when the real
 
 Treat the install as successful only when:
 
-1. controller health is `ok`
+1. controller health is `ok` after startup readiness finishes
 2. expected workers appear in the UI or status view
 3. the smoke-test task completes
 4. files appear in the workspace

package/src/config.ts

@@ -100,7 +100,7 @@ function buildConfigSchema() {
         workerProvisioningRoles: {
           type: "array" as const,
           default: [],
-          description: "Preferred on-demand roles; task-required roles can still launch automatically. Empty means controller-decided defaults across all roles",
+          description: "Preferred on-demand roles; task-required roles can still launch automatically. Empty means no preferred startup role list, so startup readiness falls back to a warm developer worker",
           items: {
             type: "string" as const,
             enum: ROLE_IDS,

package/src/controller/controller-service.ts

@@ -70,6 +70,7 @@ export function createControllerService(deps: ControllerServiceDeps): OpenClawPl
           workers: {},
           tasks: {},
           controllerRuns: {},
+          projects: {},
           messages: [],
           clarifications: {},
           repo: repoState ?? undefined,

package/src/controller/controller-tools.ts

@@ -10,6 +10,7 @@ import type {
 import { buildControllerNoWorkersMessage, hasOnDemandWorkerProvisioning, shouldBlockControllerWithoutWorkers } from "./controller-capacity.js";
 import {
   normalizeClarificationQuestionSchemas,
+  normalizeManifestCompletionOpportunities,
   normalizeManifestCreatedTasks,
   normalizeManifestDeferredTasks,
   normalizeManifestRoleList,
@@ -130,6 +131,7 @@ export function createControllerTools(deps: ControllerToolsDeps) {
         description: Type.String({ description: "Execution-ready task description with scope, expected deliverable, constraints, resolved clarifications, and no unmet predecessor dependency" }),
         priority: Type.Optional(Type.String({ description: "Priority: low, medium, high, critical" })),
         assignedRole: Type.Optional(Type.String({ description: "Exact target role ID (pm, architect, developer, qa, release-engineer, infra-engineer, devops, security-engineer, designer, marketing)" })),
+        projectName: Type.Optional(Type.String({ description: "Stable project key to reuse or create for this task (for example: ggcode, todo-rest-api)." })),
         recommendedSkills: Type.Optional(
           Type.Array(
             Type.String({
@@ -184,6 +186,7 @@ export function createControllerTools(deps: ControllerToolsDeps) {
               description,
               priority: params.priority ?? "medium",
               assignedRole: params.assignedRole ?? undefined,
+              projectName: typeof params.projectName === "string" ? params.projectName : undefined,
               recommendedSkills: Array.isArray(params.recommendedSkills) ? params.recommendedSkills : undefined,
               createdBy: "controller",
               controllerSessionKey: normalizedSessionKey || undefined,
@@ -277,6 +280,15 @@ export function createControllerTools(deps: ControllerToolsDeps) {
         ),
         handoffPlan: Type.Optional(Type.String({ description: "Brief note about how workers should report progress/handoffs across this flow" })),
         notes: Type.Optional(Type.String({ description: "Additional orchestration notes for the human/controller log" })),
+        completionOpportunities: Type.Optional(
+          Type.Array(
+            Type.Object({
+              title: Type.String({ description: "Human-facing label for an adjacent optional next step after delivery" }),
+              value: Type.String({ description: "Stable option value for this next step" }),
+              summary: Type.String({ description: "What TeamClaw could continue doing if selected" }),
+            }),
+          ),
+        ),
         requirementFullyComplete: Type.Optional(Type.Boolean({ description: "Set to true when the entire human requirement is fully satisfied — all tasks completed, no deferred tasks remaining, no follow-ups needed" })),
       }),
       async execute(_id: string, params: Record<string, unknown>) {
@@ -309,6 +321,7 @@ export function createControllerTools(deps: ControllerToolsDeps) {
           deferredTasks: normalizeManifestDeferredTasks(params.deferredTasks),
           handoffPlan: normalizeOptionalManifestText(params.handoffPlan),
           notes: normalizeOptionalManifestText(params.notes),
+          completionOpportunities: normalizeManifestCompletionOpportunities(params.completionOpportunities),
           requirementFullyComplete: Boolean(params.requirementFullyComplete),
         };
 

package/src/controller/http-server.ts

@@ -63,6 +63,7 @@ import {
   resolveTeamClawAgentWorkspaceRootDir,
   resolveTeamClawWorkspaceDir,
   resolveTeamClawProjectsDir,
+  deriveStableProjectKey,
   deriveProjectSlug,
 } from "../openclaw-workspace.js";
 import { resolvePreferredLanAddress } from "../networking.js";
@@ -92,6 +93,7 @@ const CONTROLLER_INTAKE_SESSION_PREFIX = "teamclaw-controller-web:";
 const CONTROLLER_INTAKE_AGENT_SESSION_RE = /^agent:[^:]+:(teamclaw-controller-web:[a-zA-Z0-9:_-]{1,120})$/;
 const CONTROLLER_RUN_WAIT_SLICE_MS = 30_000;
 const EXISTING_PROJECT_REUSE_HINT_RE = /\b(existing|optimi(?:s|z)e|optimi(?:s|z)ation|improvement|enhanc(?:e|ement)|follow[- ]?up|extend|update|bugfix|bug fix)\b/iu;
+const GENERIC_PROJECT_FOLLOW_UP_RE = /\b(continue|continuing|next step|what else|what's next|follow[- ]?up|more|remaining)\b|继续|接下来|下一步|还有哪些|还可以做什么/u;
 const PROJECT_MATCH_STOPWORDS = new Set([
   "a",
   "an",
@@ -459,15 +461,19 @@ function createControllerRun(
 ): ControllerRunInfo {
   const now = Date.now();
   const existingState = deps.getTeamState();
-  const inheritedProjectDir = options?.sourceTaskId
-    ? existingState?.tasks[options.sourceTaskId]?.projectDir
-    : resolveProjectDirForSession(sessionKey, existingState)
-      ?? resolveExistingProjectDirFromMessage(message, existingState);
+  const inheritedProject = options?.sourceTaskId
+    ? resolveProjectIdentityForTaskId(options.sourceTaskId, existingState)
+    : resolveProjectIdentityForSession(sessionKey, existingState)
+      ?? resolveExistingProjectIdentityFromMessage(message, existingState);
+  const explicitProjectId = extractExplicitProjectNameHint(message);
+  const projectId = inheritedProject?.projectId ?? explicitProjectId;
+  const projectDir = inheritedProject?.projectDir ?? projectId ?? deriveProjectSlug(message);
   const run: ControllerRunInfo = {
     id: generateId(),
     title: buildControllerRunTitle(message, options?.source ?? "human", options?.sourceTaskTitle),
     sessionKey,
-    projectDir: inheritedProjectDir ?? deriveProjectSlug(message),
+    projectId: projectId || undefined,
+    projectDir,
     source: options?.source ?? "human",
     sourceTaskId: options?.sourceTaskId,
     sourceTaskTitle: options?.sourceTaskTitle,
@@ -479,6 +485,13 @@ function createControllerRun(
   };
 
   const state = deps.updateTeamState((teamState) => {
+    syncProjectRegistryEntry(teamState, {
+      projectId: run.projectId,
+      projectDir: run.projectDir,
+      aliases: [run.projectId, extractExplicitProjectNameHint(message)],
+      summary: run.title,
+      updatedAt: now,
+    });
     teamState.controllerRuns[run.id] = run;
     trimControllerRuns(teamState);
   });
@@ -487,20 +500,17 @@ function createControllerRun(
   return createdRun;
 }
 
-function resolveExistingProjectDirFromMessage(
+function resolveExistingProjectIdentityFromMessage(
   message: string,
   state: TeamState | null,
-): string | undefined {
-  if (!EXISTING_PROJECT_REUSE_HINT_RE.test(message)) {
-    return undefined;
-  }
+): { projectId?: string; projectDir?: string } | undefined {
   const normalizedMessage = normalizeProjectMatchingText(message);
   if (!normalizedMessage) {
     return undefined;
   }
-  const explicitAlias = normalizeProjectMatchingText(extractProjectAliasFromText(message) ?? "");
+  const explicitAlias = normalizeProjectMatchingText(extractExplicitProjectNameHint(message) ?? "");
 
-  let best: { projectDir: string; score: number; updatedAt: number } | null = null;
+  let best: { projectId?: string; projectDir: string; score: number; updatedAt: number } | null = null;
   const candidates = collectExistingProjectCandidates(state);
   for (const candidate of candidates) {
     const normalizedAliases = Array.from(candidate.aliases)
@@ -532,27 +542,47 @@ function resolveExistingProjectDirFromMessage(
     }
     if (!best || totalScore > best.score || (totalScore === best.score && candidate.updatedAt > best.updatedAt)) {
       best = {
+        projectId: candidate.projectId,
         projectDir: candidate.projectDir,
         score: totalScore,
         updatedAt: candidate.updatedAt,
       };
     }
   }
-  return best?.projectDir;
+  if (best) {
+    return { projectId: best.projectId, projectDir: best.projectDir };
+  }
+  if ((EXISTING_PROJECT_REUSE_HINT_RE.test(message) || GENERIC_PROJECT_FOLLOW_UP_RE.test(message)) && candidates.length === 1) {
+    return {
+      projectId: candidates[0]?.projectId,
+      projectDir: candidates[0]?.projectDir,
+    };
+  }
+  return undefined;
 }
 
 function collectExistingProjectCandidates(state: TeamState | null): Array<{
+  projectId?: string;
   projectDir: string;
   aliases: Set<string>;
   searchText: string;
   updatedAt: number;
 }> {
-  const byProjectDir = new Map<string, { aliases: Set<string>; texts: string[]; updatedAt: number }>();
-  const addCandidate = (projectDir: string | undefined, text: string | undefined, updatedAt: number, alias?: string | null) => {
+  const byProjectDir = new Map<string, { projectId?: string; aliases: Set<string>; texts: string[]; updatedAt: number }>();
+  const addCandidate = (
+    projectDir: string | undefined,
+    text: string | undefined,
+    updatedAt: number,
+    alias?: string | null,
+    projectId?: string,
+  ) => {
     if (!projectDir) {
       return;
     }
-    const entry = byProjectDir.get(projectDir) ?? { aliases: new Set<string>(), texts: [], updatedAt: 0 };
+    const entry = byProjectDir.get(projectDir) ?? { projectId, aliases: new Set<string>(), texts: [], updatedAt: 0 };
+    if (!entry.projectId && projectId) {
+      entry.projectId = projectId;
+    }
     if (text && text.trim()) {
       entry.texts.push(text);
     }
@@ -563,17 +593,25 @@ function collectExistingProjectCandidates(state: TeamState | null): Array<{
     byProjectDir.set(projectDir, entry);
   };
 
+  for (const project of Object.values(state?.projects ?? {})) {
+    addCandidate(project.projectDir, project.summary, project.updatedAt, project.id, project.id);
+    for (const alias of project.aliases ?? []) {
+      addCandidate(project.projectDir, alias, project.updatedAt, alias, project.id);
+    }
+  }
   for (const run of Object.values(state?.controllerRuns ?? {})) {
-    addCandidate(run.projectDir, run.request, run.updatedAt, extractProjectAliasFromText(run.request));
-    addCandidate(run.projectDir, run.title, run.updatedAt, extractProjectAliasFromText(run.title));
+    addCandidate(run.projectDir, run.request, run.updatedAt, extractProjectAliasFromText(run.request), run.projectId);
+    addCandidate(run.projectDir, run.title, run.updatedAt, extractProjectAliasFromText(run.title), run.projectId);
+    addCandidate(run.projectDir, run.manifest?.projectName, run.updatedAt, run.manifest?.projectName, run.projectId);
   }
   for (const task of Object.values(state?.tasks ?? {})) {
-    addCandidate(task.projectDir, task.title, task.updatedAt, extractProjectAliasFromText(task.title));
-    addCandidate(task.projectDir, task.description, task.updatedAt, extractProjectAliasFromText(task.description));
-    addCandidate(task.projectDir, task.resultContract?.summary, task.updatedAt);
+    addCandidate(task.projectDir, task.title, task.updatedAt, extractProjectAliasFromText(task.title), task.projectId);
+    addCandidate(task.projectDir, task.description, task.updatedAt, extractProjectAliasFromText(task.description), task.projectId);
+    addCandidate(task.projectDir, task.resultContract?.summary, task.updatedAt, null, task.projectId);
   }
 
   return Array.from(byProjectDir.entries()).map(([projectDir, entry]) => ({
+    projectId: entry.projectId,
     projectDir,
     aliases: entry.aliases,
     searchText: entry.texts.join("\n"),
@@ -581,6 +619,119 @@ function collectExistingProjectCandidates(state: TeamState | null): Array<{
   }));
 }
 
+function extractExplicitProjectNameHint(text: string | undefined): string | undefined {
+  const value = String(text ?? "");
+  const namedMatch = value.match(/(?:品牌|brand|project\s*name|产品名|名字)\s*[:：]?\s*[`"'“”]?([a-z][a-z0-9_-]{1,39})[`"'“”]?/iu);
+  if (namedMatch?.[1]) {
+    return deriveStableProjectKey(namedMatch[1]);
+  }
+  const inlineNames = Array.from(value.matchAll(/`([a-z][a-z0-9_-]{1,39})`/giu))
+    .map((match) => deriveStableProjectKey(match[1]))
+    .filter(Boolean);
+  return inlineNames.length === 1 ? inlineNames[0] : undefined;
+}
+
+function findProjectRecordByDir(state: TeamState | null, projectDir: string | undefined) {
+  if (!state || !projectDir) {
+    return undefined;
+  }
+  return Object.values(state.projects ?? {}).find((project) => project.projectDir === projectDir);
+}
+
+function syncProjectRegistryEntry(
+  state: TeamState,
+  input: {
+    projectId?: string;
+    projectDir?: string;
+    aliases?: Array<string | undefined | null>;
+    summary?: string;
+    updatedAt: number;
+  },
+): { projectId?: string; projectDir?: string } {
+  state.projects = state.projects && typeof state.projects === "object" ? state.projects : {};
+  let normalizedProjectId = deriveStableProjectKey(input.projectId ?? "");
+  let existing = normalizedProjectId ? state.projects[normalizedProjectId] : undefined;
+  const byDir = findProjectRecordByDir(state, input.projectDir);
+  if (!existing && byDir) {
+    existing = byDir;
+  }
+  if (!existing && input.projectDir) {
+    normalizedProjectId = normalizedProjectId || deriveStableProjectKey(input.projectDir);
+    if (normalizedProjectId) {
+      existing = {
+        id: normalizedProjectId,
+        projectDir: input.projectDir,
+        aliases: [],
+        createdAt: input.updatedAt,
+        updatedAt: input.updatedAt,
+        lastUsedAt: input.updatedAt,
+      };
+      state.projects[normalizedProjectId] = existing;
+    }
+  }
+  if (!existing) {
+    return { projectId: normalizedProjectId || undefined, projectDir: input.projectDir };
+  }
+  if (normalizedProjectId && existing.id !== normalizedProjectId && !state.projects[normalizedProjectId]) {
+    delete state.projects[existing.id];
+    existing.id = normalizedProjectId;
+    state.projects[normalizedProjectId] = existing;
+  }
+  if (!existing.projectDir && input.projectDir) {
+    existing.projectDir = input.projectDir;
+  }
+  const aliasSet = new Set(existing.aliases ?? []);
+  aliasSet.add(existing.id);
+  if (existing.projectDir) {
+    aliasSet.add(existing.projectDir);
+  }
+  for (const alias of input.aliases ?? []) {
+    const normalizedAlias = deriveStableProjectKey(String(alias ?? ""));
+    if (normalizedAlias) {
+      aliasSet.add(normalizedAlias);
+    }
+  }
+  existing.aliases = Array.from(aliasSet);
+  existing.summary = input.summary || existing.summary;
+  existing.updatedAt = Math.max(existing.updatedAt || 0, input.updatedAt);
+  existing.lastUsedAt = Math.max(existing.lastUsedAt || 0, input.updatedAt);
+  return { projectId: existing.id, projectDir: existing.projectDir };
+}
+
+function resolveProjectIdentityForSession(
+  sessionKey: string,
+  state: TeamState | null,
+): { projectId?: string; projectDir?: string } | undefined {
+  const runId = findLatestControllerRunIdForSession(sessionKey, state, { preferActive: true });
+  if (!runId) {
+    return undefined;
+  }
+  const run = state?.controllerRuns[runId];
+  if (!run) {
+    return undefined;
+  }
+  const project = findProjectRecordByDir(state, run.projectDir);
+  return {
+    projectId: run.projectId ?? project?.id,
+    projectDir: run.projectDir ?? project?.projectDir,
+  };
+}
+
+function resolveProjectIdentityForTaskId(
+  taskId: string,
+  state: TeamState | null,
+): { projectId?: string; projectDir?: string } | undefined {
+  const task = state?.tasks?.[taskId];
+  if (!task) {
+    return undefined;
+  }
+  const project = findProjectRecordByDir(state, task.projectDir);
+  return {
+    projectId: task.projectId ?? project?.id,
+    projectDir: task.projectDir ?? project?.projectDir,
+  };
+}
+
 function extractProjectAliasFromText(text: string | undefined): string | null {
   const firstMeaningfulLine = String(text ?? "")
     .split(/\n+/u)
@@ -946,8 +1097,7 @@ function resolveProjectDirForSession(
   sessionKey: string,
   state: TeamState | null,
 ): string | undefined {
-  const runId = findLatestControllerRunIdForSession(sessionKey, state, { preferActive: true });
-  return runId ? state?.controllerRuns[runId]?.projectDir : undefined;
+  return resolveProjectIdentityForSession(sessionKey, state)?.projectDir;
 }
 
 function resolveControllerWorkflowSessionKey(task: TaskInfo, state: TeamState | null): string | undefined {
@@ -1121,15 +1271,16 @@ function buildBackfilledControllerManifest(
   for (const roleId of inferManifestRolesFromText(request)) {
     inferredRoles.add(roleId);
   }
-  // When no roles could be inferred at all (model didn't call the tool and didn't
-  // mention any role names), fall back to "developer" as the most general purpose role
-  // so that the intake run still has usable machine-readable state.
+  // When no roles could be inferred at all, default the first-pass requirement analysis
+  // to architect rather than developer. This keeps repository analysis, feasibility
+  // assessment, and technical decomposition out of implementation-only developer tasks.
   if (inferredRoles.size === 0) {
-    inferredRoles.add("developer");
+    inferredRoles.add("architect");
   }
   const clarificationQuestions = inferClarificationQuestionsFromReply(rawReply);
   return {
     version: "1.0",
+    projectName: actualCreatedTasks.find((task) => task.projectId)?.projectId,
     requirementSummary: request.replace(/\s+/g, " ").trim() || "Controller requirement summary unavailable.",
     requiredRoles: Array.from(inferredRoles),
     clarificationsNeeded: clarificationQuestions.length > 0 && actualCreatedTasks.length === 0,
@@ -1158,6 +1309,30 @@ function looksLikeSoftwareRequirement(request: string): boolean {
   return /(api|backend|frontend|fastapi|react|vue|node|python|typescript|javascript|sql|database|service|app|web|mobile|docker|kubernetes|deploy|测试|系统|平台|接口|服务|数据库|应用|前端|后端)/.test(normalized);
 }
 
+function isArchitectureFirstRequirement(request: string): boolean {
+  const normalized = request.toLowerCase();
+  return /(analy[sz]e|analysis|assess|feasibility|architecture|architect|design|plan|decompose|migration|port|rewrite|refactor|audit|review|repo|repository|codebase|golang|go\b|typescript|可行性|评估|架构|设计|分析|拆分|迁移|移植|重写|审计|仓库|代码库)/.test(normalized);
+}
+
+function chooseFallbackAssignedRole(manifest: ControllerOrchestrationManifest, request: string): RoleId {
+  const requiredRoles = manifest.requiredRoles;
+  if (requiredRoles.length === 0) {
+    return isArchitectureFirstRequirement(request) ? "architect" : "developer";
+  }
+  if (isArchitectureFirstRequirement(request)) {
+    if (requiredRoles.includes("architect")) {
+      return "architect";
+    }
+    if (requiredRoles.includes("pm")) {
+      return "pm";
+    }
+  }
+  if (requiredRoles.includes("developer") && requiredRoles.length === 1) {
+    return "developer";
+  }
+  return requiredRoles[0] ?? (isArchitectureFirstRequirement(request) ? "architect" : "developer");
+}
+
 function buildFallbackControllerTaskTitle(request: string, assignedRole?: RoleId): string {
   const firstMeaningfulLine = request
     .split(/\n+/)
@@ -1172,6 +1347,9 @@ function buildFallbackControllerTaskTitle(request: string, assignedRole?: RoleId
         : `Implement ${capped}`;
     }
   }
+  if (assignedRole === "architect") {
+    return "Analyze the repository and produce an architecture/feasibility plan";
+  }
   return assignedRole === "developer"
     ? "Implement the requested software deliverable"
     : `Perform the requested ${assignedRole || "software"} work`;
@@ -1185,6 +1363,7 @@ async function createControllerManagedTask(
     assignedRole?: RoleId;
     createdBy: string;
     controllerSessionKey?: string;
+    projectName?: string;
     recommendedSkills?: string[];
   },
   deps: ControllerHttpDeps,
@@ -1196,15 +1375,12 @@ async function createControllerManagedTask(
     ? normalizeControllerIntakeSessionKey(input.controllerSessionKey)
     : undefined;
 
-  let projectDir: string | undefined;
-  if (normalizedSessionKey) {
-    const runId = findLatestControllerRunIdForSession(normalizedSessionKey, deps.getTeamState(), { preferActive: true });
-    const parentRun = runId ? deps.getTeamState()?.controllerRuns[runId] : undefined;
-    projectDir = parentRun?.projectDir;
-  }
-  if (!projectDir) {
-    projectDir = deriveProjectSlug(input.title);
-  }
+  const inheritedProject = normalizedSessionKey
+    ? resolveProjectIdentityForSession(normalizedSessionKey, deps.getTeamState())
+    : undefined;
+  const explicitProjectId = deriveStableProjectKey(input.projectName ?? "");
+  const projectId = inheritedProject?.projectId ?? explicitProjectId || undefined;
+  const projectDir = inheritedProject?.projectDir ?? projectId ?? deriveProjectSlug(input.title);
 
   const normalizedRecommendedSkills = normalizeRecommendedSkills(input.recommendedSkills ?? []);
   const task: TaskInfo = {
@@ -1217,12 +1393,22 @@ async function createControllerManagedTask(
     createdBy: input.createdBy,
     recommendedSkills: normalizedRecommendedSkills.length > 0 ? normalizedRecommendedSkills : undefined,
     controllerSessionKey: normalizedSessionKey,
+    projectId,
     projectDir,
     createdAt: now,
     updatedAt: now,
   };
 
   deps.updateTeamState((state) => {
+    const project = syncProjectRegistryEntry(state, {
+      projectId: task.projectId,
+      projectDir: task.projectDir,
+      aliases: [input.projectName, task.projectId],
+      summary: task.title,
+      updatedAt: now,
+    });
+    task.projectId = project.projectId;
+    task.projectDir = project.projectDir;
     state.tasks[taskId] = task;
   });
   recordTaskExecutionEvent(taskId, {
@@ -1283,9 +1469,7 @@ async function maybeBackfillExecutionReadyTask(
     return [];
   }
 
-  const assignedRole = manifest.requiredRoles.includes("developer")
-    ? "developer"
-    : manifest.requiredRoles[0];
+  const assignedRole = chooseFallbackAssignedRole(manifest, request);
   const task = await createControllerManagedTask({
     title: buildFallbackControllerTaskTitle(request, assignedRole),
     description: request,
@@ -1528,17 +1712,43 @@ function normalizeComparableText(value: string): string {
 function buildManifestClarificationEntries(
   manifest: ControllerOrchestrationManifest,
 ): Array<{ question: string; questionSchema?: ClarificationRequest["questionSchema"] }> {
+  const opportunities = Array.isArray(manifest.completionOpportunities)
+    ? manifest.completionOpportunities.filter((entry) => entry.title && entry.value && entry.summary)
+    : [];
+  const completionEntries = manifest.requirementFullyComplete && opportunities.length > 0
+    ? [{
+      question: "Would you like TeamClaw to continue with one of these adjacent next steps?",
+      questionSchema: {
+        kind: "single-select" as const,
+        title: "What should TeamClaw do next?",
+        description: opportunities.map((entry) => `- ${entry.title}: ${entry.summary}`).join("\n"),
+        required: false,
+        options: opportunities.map((entry) => ({
+          value: entry.value,
+          label: entry.title,
+          hint: entry.summary,
+        })),
+        allowOther: true,
+      },
+    }]
+    : [];
   const normalizedQuestions = manifest.clarificationQuestions
     .map((entry) => String(entry || "").trim())
     .filter(Boolean);
   const schemas = Array.isArray(manifest.clarificationSchemas) ? manifest.clarificationSchemas : [];
   if (schemas.length > 0) {
-    return schemas.map((schema, index) => ({
-      question: normalizedQuestions[index] || schema.title,
-      questionSchema: schema,
-    }));
+    return [
+      ...schemas.map((schema, index) => ({
+        question: normalizedQuestions[index] || schema.title,
+        questionSchema: schema,
+      })),
+      ...completionEntries,
+    ];
   }
-  return normalizedQuestions.map((question) => ({ question }));
+  return [
+    ...normalizedQuestions.map((question) => ({ question })),
+    ...completionEntries,
+  ];
 }
 
 function syncControllerRunClarifications(
@@ -1548,19 +1758,33 @@ function syncControllerRunClarifications(
   deps: ControllerHttpDeps,
 ): ClarificationRequest[] {
   const entries = buildManifestClarificationEntries(manifest);
-  if (entries.length === 0) {
-    return [];
-  }
-
   const created: ClarificationRequest[] = [];
+  const superseded: ClarificationRequest[] = [];
   const now = Date.now();
   deps.updateTeamState((state) => {
+    const desiredQuestionKeys = new Set(
+      entries.map((entry) => normalizeComparableText(entry.question)),
+    );
     const existingQuestions = new Map(
       Object.values(state.clarifications)
         .filter((item) => item.controllerRunId === controllerRunId)
         .map((item) => [normalizeComparableText(item.question), item]),
     );
 
+    for (const [key, clarification] of existingQuestions.entries()) {
+      if (
+        clarification.status === "pending"
+        && !desiredQuestionKeys.has(key)
+      ) {
+        clarification.status = "answered";
+        clarification.answer = "Automatically superseded by the latest controller clarification set.";
+        clarification.answeredBy = "system";
+        clarification.answeredAt = now;
+        clarification.updatedAt = now;
+        superseded.push({ ...clarification });
+      }
+    }
+
     for (const entry of entries) {
       const key = normalizeComparableText(entry.question);
       if (existingQuestions.has(key)) {
@@ -1588,6 +1812,9 @@ function syncControllerRunClarifications(
   for (const clarification of created) {
     deps.wsServer.broadcastUpdate({ type: "clarification:requested", data: clarification });
   }
+  for (const clarification of superseded) {
+    deps.wsServer.broadcastUpdate({ type: "clarification:answered", data: clarification });
+  }
   return created;
 }
 
@@ -1597,6 +1824,7 @@ function reconcileControllerClarifications(deps: ControllerHttpDeps): TeamState
     return null;
   }
 
+  const superseded: ClarificationRequest[] = [];
   deps.updateTeamState((draft) => {
     const runsBySession = new Map<string, ControllerRunInfo[]>();
     for (const run of Object.values(draft.controllerRuns)) {
@@ -1627,9 +1855,14 @@ function reconcileControllerClarifications(deps: ControllerHttpDeps): TeamState
       clar.answeredBy = "system";
       clar.answeredAt = supersedingRun.updatedAt;
       clar.updatedAt = supersedingRun.updatedAt;
+      superseded.push({ ...clar });
     }
   });
 
+  for (const clarification of superseded) {
+    deps.wsServer.broadcastUpdate({ type: "clarification:answered", data: clarification });
+  }
+
   for (const run of Object.values(state.controllerRuns)) {
     if (!run.manifest?.clarificationsNeeded) {
       continue;
@@ -2263,6 +2496,49 @@ function buildRecommendedSkillsContext(task: TaskInfo): string {
   ].join("\n");
 }
 
+function buildTaskContextSnapshot(task: TaskInfo, state: TeamState | null): TaskAssignmentPayload["teamContext"] | undefined {
+  if (!state || !task.controllerSessionKey) {
+    return undefined;
+  }
+  const normalizedSessionKey = normalizeControllerIntakeSessionKey(task.controllerSessionKey);
+  const summarize = (candidate: TaskInfo) => ({
+    id: candidate.id,
+    title: candidate.title,
+    assignedRole: candidate.assignedRole,
+    status: candidate.status,
+    summary: summarizeTaskForAssignment(candidate),
+  });
+  const sameSessionTasks = Object.values(state.tasks)
+    .filter((candidate) => candidate.id !== task.id)
+    .filter((candidate) => normalizeControllerIntakeSessionKey(candidate.controllerSessionKey) === normalizedSessionKey);
+  const latestRun = Object.values(state.controllerRuns)
+    .filter((run) => normalizeControllerIntakeSessionKey(run.sessionKey) === normalizedSessionKey)
+    .sort((a, b) => b.updatedAt - a.updatedAt)[0];
+  return {
+    requirementSummary: latestRun?.manifest?.requirementSummary || latestRun?.request,
+    projectName: latestRun?.manifest?.projectName,
+    requiredRoles: latestRun?.manifest?.requiredRoles,
+    activeTasks: sameSessionTasks.filter((candidate) => candidate.status === "assigned" || candidate.status === "in_progress").slice(0, 8).map(summarize),
+    blockedTasks: sameSessionTasks.filter((candidate) => candidate.status === "blocked").slice(0, 6).map(summarize),
+    recentCompletedTasks: sameSessionTasks
+      .filter((candidate) => candidate.status === "completed")
+      .sort((a, b) => (b.completedAt ?? b.updatedAt) - (a.completedAt ?? a.updatedAt))
+      .slice(0, 8)
+      .map(summarize),
+    pendingClarifications: Object.values(state.clarifications)
+      .filter((clarification) => clarification.status === "pending")
+      .filter((clarification) => normalizeControllerIntakeSessionKey(clarification.controllerSessionKey) === normalizedSessionKey)
+      .slice(0, 5)
+      .map((clarification) => ({
+        question: clarification.question,
+        blockingReason: clarification.blockingReason,
+      })),
+    handoffPlan: latestRun?.manifest?.handoffPlan,
+    notes: latestRun?.manifest?.notes,
+    kickoffSummary: latestRun?.manifest?.kickoffPlan?.summary,
+  };
+}
+
 function buildTaskAssignmentDescription(task: TaskInfo, state: TeamState | null, repoInfo?: RepoSyncInfo): string {
   const parts = [task.description];
   const projectContext = buildProjectDirectoryContext(task.projectDir);
@@ -3326,6 +3602,7 @@ async function dispatchTaskToWorker(
     executionSessionKey: executionIdentity.executionSessionKey,
     executionIdempotencyKey: executionIdentity.executionIdempotencyKey,
     repo: repoInfo,
+    teamContext: buildTaskContextSnapshot(task, state ?? null),
   };
 
   const res = await fetch(`${worker.url}/api/v1/tasks/assign`, {
@@ -3757,6 +4034,9 @@ async function handleRequest(
     const controllerSessionKey = createdBy === "controller" && typeof body.controllerSessionKey === "string" && body.controllerSessionKey.trim()
       ? normalizeControllerIntakeSessionKey(body.controllerSessionKey)
       : undefined;
+    const explicitProjectName = typeof body.projectName === "string" && body.projectName.trim()
+      ? deriveStableProjectKey(body.projectName)
+      : undefined;
     const recommendedSkills = normalizeRecommendedSkills(
       Array.isArray(body.recommendedSkills) ? body.recommendedSkills.map((entry) => String(entry ?? "")) : [],
     );
@@ -3781,16 +4061,11 @@ async function handleRequest(
     const now = Date.now();
     const repoState = await refreshControllerRepoState(deps);
 
-    // Resolve project directory: inherit from parent run, or generate from title
-    let projectDir: string | undefined;
-    if (controllerSessionKey) {
-      const runId = findLatestControllerRunIdForSession(controllerSessionKey, getTeamState(), { preferActive: true });
-      const parentRun = runId ? getTeamState()?.controllerRuns[runId] : undefined;
-      projectDir = parentRun?.projectDir;
-    }
-    if (!projectDir) {
-      projectDir = deriveProjectSlug(title);
-    }
+    const inheritedProject = controllerSessionKey
+      ? resolveProjectIdentityForSession(controllerSessionKey, getTeamState())
+      : undefined;
+    const projectId = inheritedProject?.projectId ?? explicitProjectName || undefined;
+    const projectDir = inheritedProject?.projectDir ?? projectId ?? deriveProjectSlug(title);
 
     const task: TaskInfo = {
       id: taskId,
@@ -3802,12 +4077,22 @@ async function handleRequest(
       createdBy,
       recommendedSkills: recommendedSkills.length > 0 ? recommendedSkills : undefined,
       controllerSessionKey,
+      projectId,
       projectDir,
       createdAt: now,
       updatedAt: now,
     };
 
     updateTeamState((s) => {
+      const project = syncProjectRegistryEntry(s, {
+        projectId: task.projectId,
+        projectDir: task.projectDir,
+        aliases: [explicitProjectName, task.projectId],
+        summary: task.title,
+        updatedAt: now,
+      });
+      task.projectId = project.projectId;
+      task.projectDir = project.projectDir;
       s.tasks[taskId] = task;
     });
     recordTaskExecutionEvent(taskId, {
@@ -4409,14 +4694,31 @@ async function handleRequest(
 
     const updatedRun = updateControllerRun(runId, deps, (run) => {
       run.manifest = manifest;
+      const state = deps.getTeamState();
+      if (state) {
+        const project = syncProjectRegistryEntry(state, {
+          projectId: manifest.projectName ?? run.projectId,
+          projectDir: run.projectDir ?? manifest.projectName,
+          aliases: [manifest.projectName, run.projectId],
+          summary: manifest.requirementSummary,
+          updatedAt: Date.now(),
+        });
+        run.projectId = project.projectId;
+        run.projectDir = project.projectDir;
+      }
 
       if (run.projectDir) {
         const state = deps.getTeamState();
         if (state) {
           for (const taskId of run.createdTaskIds) {
             const task = state.tasks[taskId];
-            if (task && !task.projectDir) {
-              task.projectDir = run.projectDir;
+            if (task) {
+              if (!task.projectDir) {
+                task.projectDir = run.projectDir;
+              }
+              if (!task.projectId) {
+                task.projectId = run.projectId;
+              }
             }
           }
         }

package/src/controller/orchestration-manifest.ts

@@ -1,11 +1,13 @@
 import type {
   ClarificationQuestionOption,
   ClarificationQuestionSchema,
+  ControllerManifestCompletionOpportunity,
   ControllerManifestCreatedTask,
   ControllerManifestDeferredTask,
   ControllerOrchestrationManifest,
   RoleId,
 } from "../types.js";
+import { deriveStableProjectKey } from "../openclaw-workspace.js";
 
 const TEAMCLAW_ROLE_IDS = new Set<RoleId>([
   "pm",
@@ -145,6 +147,20 @@ export function normalizeManifestDeferredTasks(raw: unknown): ControllerManifest
     .filter((entry) => entry.title && entry.blockedBy && entry.whenReady);
 }
 
+export function normalizeManifestCompletionOpportunities(raw: unknown): ControllerManifestCompletionOpportunity[] {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw
+    .filter((entry): entry is Record<string, unknown> => !!entry && typeof entry === "object")
+    .map((entry) => ({
+      title: typeof entry.title === "string" ? entry.title.trim() : "",
+      value: typeof entry.value === "string" ? entry.value.trim() : "",
+      summary: typeof entry.summary === "string" ? entry.summary.trim() : "",
+    }))
+    .filter((entry) => entry.title && entry.value && entry.summary);
+}
+
 export function normalizeControllerManifest(raw: unknown): ControllerOrchestrationManifest | null {
   if (!raw || typeof raw !== "object") {
     return null;
@@ -158,7 +174,9 @@ export function normalizeControllerManifest(raw: unknown): ControllerOrchestrati
   const clarificationQuestions = normalizeManifestStringList(input.clarificationQuestions);
   return {
     version: typeof input.version === "string" && input.version.trim() ? input.version.trim() : "1.0",
-    projectName: typeof input.projectName === "string" && input.projectName.trim() ? input.projectName.trim() : undefined,
+    projectName: typeof input.projectName === "string" && input.projectName.trim()
+      ? (deriveStableProjectKey(input.projectName.trim()) || input.projectName.trim())
+      : undefined,
     requirementSummary,
     requiredRoles: normalizeManifestRoleList(input.requiredRoles),
     clarificationsNeeded: Boolean(input.clarificationsNeeded),
@@ -168,6 +186,7 @@ export function normalizeControllerManifest(raw: unknown): ControllerOrchestrati
     deferredTasks: normalizeManifestDeferredTasks(input.deferredTasks),
     handoffPlan: normalizeOptionalManifestText(input.handoffPlan),
     notes: normalizeOptionalManifestText(input.notes),
+    completionOpportunities: normalizeManifestCompletionOpportunities(input.completionOpportunities),
     requirementFullyComplete: Boolean(input.requirementFullyComplete),
   };
 }

package/src/controller/prompt-injector.ts

@@ -129,6 +129,7 @@ export function createControllerPromptInjector(deps: ControllerPromptDeps) {
     parts.push("");
     parts.push("## Out-of-Scope Requests");
     parts.push("- TeamClaw is a software development team. You handle: coding, architecture, design, testing, deployment, documentation, security review, and related technical work.");
+    parts.push("- Do not infer that the user lacks rights to work on a codebase just because it contains binaries, bundles, minified code, generated artifacts, proprietary branding, or unusual repository structure. Unless the user explicitly states a restriction, keep the decision technical rather than ownership-based.");
     parts.push("- If the human asks for something clearly non-technical (cooking, weather, personal advice, general knowledge, creative writing unrelated to software), politely decline in your reply text AND still call teamclaw_submit_manifest with createdTasks=[], requiredRoles=[], and requirementSummary explaining why you declined.");
     parts.push("- If the request is borderline (e.g. 'write a blog post about our API'), lean toward accepting it and assigning to the appropriate role (marketing, pm).");
     parts.push("- REMEMBER: You must ALWAYS call teamclaw_submit_manifest, even when declining. The system cannot record your decision without it.");
@@ -169,9 +170,17 @@ type ExistingProjectInfo = { dir: string; summary: string };
 function listExistingProjects(state: TeamState | null): ExistingProjectInfo[] {
   const projects: ExistingProjectInfo[] = [];
 
-  // Gather from completed tasks with projectDir
   const seenDirs = new Set<string>();
   if (state) {
+    for (const project of Object.values(state.projects ?? {})) {
+      if (project.projectDir && !seenDirs.has(project.projectDir)) {
+        seenDirs.add(project.projectDir);
+        const aliases = project.aliases.filter(Boolean);
+        const aliasSummary = aliases.length > 0 ? `aliases: ${aliases.join(", ")}` : "";
+        const summary = [project.summary, aliasSummary].filter(Boolean).join(" | ") || "(registered project)";
+        projects.push({ dir: project.projectDir, summary });
+      }
+    }
     for (const task of Object.values(state.tasks)) {
       if (task.projectDir && !seenDirs.has(task.projectDir)) {
         seenDirs.add(task.projectDir);

package/src/controller/worker-provisioning.ts

@@ -1416,7 +1416,7 @@ function buildProvisionedWorkerConfig(
   teamclawConfig.workerProvisioningControllerUrl = "";
   teamclawConfig.workerProvisioningRoles = [];
   teamclawConfig.workerProvisioningMinPerRole = 0;
-  teamclawConfig.workerProvisioningMaxPerRole = 1;
+  teamclawConfig.workerProvisioningMaxPerRole = 10;
   teamclawConfig.workerProvisioningIdleTtlMs = controllerConfig.workerProvisioningIdleTtlMs;
   teamclawConfig.workerProvisioningStartupTimeoutMs = controllerConfig.workerProvisioningStartupTimeoutMs;
   teamclawConfig.workerProvisioningImage = "";

package/src/openclaw-workspace.ts

@@ -438,13 +438,17 @@ export function buildTeamClawProjectAgentRelativePath(
  *
  * Example: "Build a payment system with Stripe" → "build-a-payment-system-with-stripe-k3f9m2"
  */
-export function deriveProjectSlug(text: string): string {
-  const slug = text
+export function deriveStableProjectKey(text: string): string {
+  return text
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, "-")
     .replace(/^-+|-+$/g, "")
     .slice(0, 50)
-    .replace(/-+$/, "");
+    .replace(/-+$/g, "");
+}
+
+export function deriveProjectSlug(text: string): string {
+  const slug = deriveStableProjectKey(text);
   const suffix = randomSuffix(6);
   return slug ? `${slug}-${suffix}` : suffix;
 }

package/src/state.ts

@@ -100,6 +100,9 @@ async function loadTeamState(teamName: string): Promise<TeamState | null> {
     if (!parsed.controllerRuns || typeof parsed.controllerRuns !== "object") {
       parsed.controllerRuns = {};
     }
+    if (!parsed.projects || typeof parsed.projects !== "object") {
+      parsed.projects = {};
+    }
     if (!Array.isArray(parsed.messages)) {
       parsed.messages = [];
     }
@@ -136,6 +139,9 @@ async function saveTeamState(state: TeamState): Promise<void> {
   state.controllerRuns = state.controllerRuns && typeof state.controllerRuns === "object"
     ? state.controllerRuns
     : {};
+  state.projects = state.projects && typeof state.projects === "object"
+    ? state.projects
+    : {};
   await enqueueAtomicWrite(filePath, `${JSON.stringify(state, null, 2)}\n`);
 }
 

package/src/types.ts

@@ -110,6 +110,7 @@ export type TaskInfo = {
   createdBy: string;
   recommendedSkills?: string[];
   controllerSessionKey?: string;
+  projectId?: string;
   projectDir?: string;
   createdAt: number;
   updatedAt: number;
@@ -147,6 +148,18 @@ export type TaskAssignmentPayload = {
   executionSessionKey?: string;
   executionIdempotencyKey?: string;
   repo?: RepoSyncInfo;
+  teamContext?: {
+    requirementSummary?: string;
+    projectName?: string;
+    requiredRoles?: RoleId[];
+    activeTasks?: Array<{ id: string; title: string; assignedRole?: RoleId; status: TaskStatus; summary?: string }>;
+    blockedTasks?: Array<{ id: string; title: string; assignedRole?: RoleId; status: TaskStatus; summary?: string }>;
+    recentCompletedTasks?: Array<{ id: string; title: string; assignedRole?: RoleId; status: TaskStatus; summary?: string }>;
+    pendingClarifications?: Array<{ question: string; blockingReason?: string }>;
+    handoffPlan?: string;
+    notes?: string;
+    kickoffSummary?: string;
+  };
 };
 
 export type ControllerRunSource = "human" | "task_follow_up";
@@ -274,6 +287,12 @@ export type ControllerManifestDeferredTask = {
   whenReady: string;
 };
 
+export type ControllerManifestCompletionOpportunity = {
+  title: string;
+  value: string;
+  summary: string;
+};
+
 export type ClarificationQuestionKind = "single-select" | "multi-select" | "number" | "text";
 
 export type ClarificationQuestionOption = {
@@ -309,6 +328,7 @@ export type ControllerOrchestrationManifest = {
   deferredTasks: ControllerManifestDeferredTask[];
   handoffPlan?: string;
   notes?: string;
+  completionOpportunities?: ControllerManifestCompletionOpportunity[];
   /** Controller signals that the entire human requirement is fully satisfied — no more tasks or follow-ups needed. */
   requirementFullyComplete?: boolean;
   /** Team kickoff plan — populated when controller uses collaborative planning. */
@@ -326,6 +346,7 @@ export type ControllerRunInfo = {
   request: string;
   reply?: string;
   error?: string;
+  projectId?: string;
   projectDir?: string;
   createdTaskIds: string[];
   manifest?: ControllerOrchestrationManifest;
@@ -492,6 +513,7 @@ export type TeamState = {
   workers: Record<string, WorkerInfo>;
   tasks: Record<string, TaskInfo>;
   controllerRuns: Record<string, ControllerRunInfo>;
+  projects: Record<string, TeamProjectInfo>;
   messages: TeamMessage[];
   clarifications: Record<string, ClarificationRequest>;
   repo?: GitRepoState;
@@ -502,6 +524,16 @@ export type TeamState = {
   updatedAt: number;
 };
 
+export type TeamProjectInfo = {
+  id: string;
+  projectDir: string;
+  aliases: string[];
+  summary?: string;
+  createdAt: number;
+  updatedAt: number;
+  lastUsedAt: number;
+};
+
 export type DeliveryReportRecord = {
   id: string;
   sessionKey: string;