@teamclaws/teamclaw 2026.3.25 → 2026.3.26-2

package/src/ui/style.css

@@ -301,6 +301,19 @@ body {
   margin-bottom: 6px;
   line-height: 1.5;
 }
+.task-contract-summary {
+  margin-bottom: 8px;
+  padding: 8px 10px;
+  border-radius: 10px;
+  border: 1px solid rgba(99, 102, 241, 0.2);
+  background: rgba(99, 102, 241, 0.08);
+  color: var(--text-secondary);
+  font-size: 12px;
+  line-height: 1.5;
+}
+.task-contract-summary strong {
+  color: var(--text-primary);
+}
 .skill-pills {
   display: flex;
   flex-wrap: wrap;
@@ -558,6 +571,135 @@ body {
   font-size: 13px;
 }
 
+.contract-card {
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--accent);
+  border-radius: 12px;
+  padding: 12px 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.contract-card-completed { border-left-color: var(--success); }
+.contract-card-failed { border-left-color: var(--danger); }
+.contract-card-blocked,
+.contract-card-handoff { border-left-color: var(--warning); }
+.contract-card-in_progress,
+.contract-card-review,
+.contract-card-update,
+.contract-card-coordination,
+.contract-card-question { border-left-color: var(--info); }
+.contract-card-review-request,
+.contract-card-review-response { border-left-color: #8b5cf6; }
+.contract-card-announcement,
+.contract-card-manifest { border-left-color: var(--accent-hover); }
+
+.contract-card-header {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.contract-card-kicker,
+.contract-meta-label,
+.contract-section-title,
+.message-meta {
+  color: var(--text-muted);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.contract-card-title {
+  font-size: 15px;
+  line-height: 1.45;
+  color: var(--text-primary);
+}
+
+.contract-meta-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+  gap: 10px;
+}
+
+.contract-meta-item {
+  padding: 10px 12px;
+  border: 1px solid rgba(255, 255, 255, 0.06);
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.contract-meta-value {
+  margin-top: 4px;
+  font-size: 13px;
+  color: var(--text-primary);
+  line-height: 1.5;
+}
+
+.contract-section {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.contract-markdown,
+.timeline-raw-markdown,
+.timeline-contract-note {
+  font-size: 13px;
+  line-height: 1.6;
+  color: var(--text-primary);
+}
+
+.contract-list {
+  padding-left: 18px;
+  color: var(--text-primary);
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.contract-list li {
+  line-height: 1.6;
+}
+
+.contract-chip-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.contract-chip {
+  display: inline-flex;
+  align-items: center;
+  min-height: 28px;
+  padding: 4px 10px;
+  border-radius: 999px;
+  border: 1px solid rgba(96, 165, 250, 0.22);
+  background: rgba(96, 165, 250, 0.1);
+  color: #c7d2fe;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.contract-reference-row .contract-chip {
+  border-color: rgba(52, 211, 153, 0.22);
+  background: rgba(52, 211, 153, 0.08);
+  color: #bbf7d0;
+}
+
+.contract-role-row .contract-chip {
+  border-color: rgba(168, 85, 247, 0.22);
+  background: rgba(168, 85, 247, 0.08);
+  color: #e9d5ff;
+}
+
+.contract-inline-note {
+  color: var(--text-secondary);
+}
+
 .messages-feed {
   display: flex;
   flex-direction: column;
@@ -592,6 +734,12 @@ body {
 .message-type.review-request { background: #7c3aed; color: #fff; }
 
 .message-content { font-size: 13px; color: var(--text-primary); line-height: 1.5; }
+.message-meta {
+  margin-bottom: 8px;
+}
+.message-card .contract-card {
+  margin-bottom: 10px;
+}
 
 .create-task-form {
   max-width: 500px;
@@ -1327,6 +1475,10 @@ body {
   word-break: break-word;
   overflow-wrap: anywhere;
 }
+.timeline-entry-body .contract-card + .timeline-raw-markdown,
+.timeline-entry-body .timeline-contract-note + .timeline-contract-note {
+  margin-top: 10px;
+}
 
 .task-detail-output-stream {
   display: flex;

package/src/worker/http-handler.ts

@@ -62,6 +62,12 @@ export function createWorkerHttpHandler(
         const recommendedSkills = Array.isArray(body.recommendedSkills)
           ? body.recommendedSkills.map((entry) => String(entry ?? ""))
           : undefined;
+        const executionSessionKey = typeof body.executionSessionKey === "string"
+          ? body.executionSessionKey
+          : undefined;
+        const executionIdempotencyKey = typeof body.executionIdempotencyKey === "string"
+          ? body.executionIdempotencyKey
+          : undefined;
         const repo = body.repo && typeof body.repo === "object"
           ? body.repo as TaskAssignmentPayload["repo"]
           : undefined;
@@ -74,13 +80,15 @@ export function createWorkerHttpHandler(
         logger.info(`Worker: received task assignment - ${title} (${taskId})`);
 
         if (taskExecutor && resultReporter) {
-          taskExecutor({
-            taskId,
-            title,
-            description,
-            recommendedSkills,
-            repo,
-          })
+            taskExecutor({
+              taskId,
+              title,
+              description,
+              recommendedSkills,
+              executionSessionKey,
+              executionIdempotencyKey,
+              repo,
+            })
             .then((result) => {
               if (isTaskCancelled?.(taskId)) {
                 logger.info(`Worker: skipping result report for cancelled task ${taskId}`);

package/src/worker/prompt-injector.ts

@@ -51,6 +51,8 @@ export function createWorkerPromptInjector(
     parts.push("11. Treat file paths from documents, plans, and teammate messages as hints, not guarantees. Verify the real path exists in the current workspace before reading or editing it; if it does not exist, search for the closest real file and note the drift instead of repeatedly calling missing paths.");
     parts.push("12. The workspace may be backed by a TeamClaw-managed git repository. Treat the current checkout as canonical project state; do not delete `.git` or replace the repo with ad-hoc archives.");
     parts.push("13. If the assigned task includes recommended skills, use those exact skill slugs first. Missing skills should be searched/installed before execution when supported by the runtime.");
+    parts.push("14. Important: submit structured collaboration contracts, not only prose. Use teamclaw_submit_result_contract before your final reply, use structured fields on progress/handoff/review/message tools, and use clarification tools instead of hiding questions inside freeform output.");
+    parts.push("15. Do not use sessions_yield or end your turn while background work, coding agents, or process sessions are still running. A TeamClaw task is only done when you have the real final deliverable, not when a helper session is still working.");
     parts.push(`Worker ID: ${identity.workerId}`);
     parts.push(`Controller: ${identity.controllerUrl}`);
 

package/src/worker/skill-installer.ts

@@ -7,6 +7,7 @@ import { resolveDefaultOpenClawWorkspaceDir } from "../openclaw-workspace.js";
 import type { TaskAssignmentPayload, TaskExecutionEventInput } from "../types.js";
 
 type SkillCli = "openclaw" | "clawhub";
+const ON_DEMAND_DISCOVERY_SKILLS = new Set(["find-skills"]);
 
 type CommandResult = {
   ok: boolean;
@@ -185,6 +186,18 @@ export async function installRecommendedSkills(
   });
 
   for (const requestedSkill of recommendedSkills) {
+    if (ON_DEMAND_DISCOVERY_SKILLS.has(normalizeKey(requestedSkill))) {
+      skipped.push(requestedSkill);
+      events.push({
+        type: "lifecycle",
+        phase: "skill_install_skipped",
+        source: "worker",
+        status: "running",
+        message: `Skipping automatic install of discovery skill ${requestedSkill}; invoke it on demand inside the task if needed.`,
+      });
+      continue;
+    }
+
     let resolvedSlug = isSkillSlug(requestedSkill) ? requestedSkill : undefined;
     const installedPath = resolvedSlug ? buildInstalledSkillPath(workspaceDir, resolvedSlug) : "";
 

package/src/worker/tools.ts

@@ -1,4 +1,15 @@
 import { Type } from "@sinclair/typebox";
+import {
+  backfillWorkerProgressContract,
+  ensureTeamMessageContract,
+  normalizeContractRole,
+  normalizeContractStringList,
+  normalizeOptionalContractText,
+  normalizeTaskHandoffContract,
+  normalizeWorkerProgressContract,
+  normalizeWorkerTaskResultContract,
+  renderWorkerProgressText,
+} from "../interaction-contracts.js";
 import type { PluginConfig, WorkerIdentity } from "../types.js";
 
 const ALLOWED_PROGRESS_STATUSES = new Set(["in_progress", "review"]);
@@ -20,6 +31,10 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         targetRole: Type.String({ description: "Exact target role ID (pm, architect, developer, qa, release-engineer, infra-engineer, devops, security-engineer, designer, marketing)" }),
         question: Type.String({ description: "The question to ask" }),
         taskId: Type.Optional(Type.String({ description: "Related task ID if any" })),
+        summary: Type.Optional(Type.String({ description: "Short structured summary for this question" })),
+        details: Type.Optional(Type.String({ description: "Optional extra context for the peer" })),
+        requestedAction: Type.Optional(Type.String({ description: "Concrete response/action needed from the peer" })),
+        references: Type.Optional(Type.Array(Type.String({ description: "Relevant task IDs, file paths, or artifact references" }))),
       }),
       async execute(_id: string, params: Record<string, unknown>) {
         const identity = getIdentity();
@@ -29,12 +44,25 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
 
         const targetRole = String(params.targetRole ?? "");
         const question = String(params.question ?? "");
+        const normalizedTargetRole = normalizeContractRole(targetRole);
 
         if (!targetRole || !question) {
           return { content: [{ type: "text" as const, text: "targetRole and question are required." }] };
         }
 
         try {
+          const contract = ensureTeamMessageContract(null, {
+            type: "direct",
+            content: question,
+            toRole: normalizedTargetRole,
+            taskId: typeof params.taskId === "string" ? params.taskId : undefined,
+            summary: typeof params.summary === "string" ? params.summary : undefined,
+            details: typeof params.details === "string" ? params.details : undefined,
+            requestedAction: typeof params.requestedAction === "string" ? params.requestedAction : undefined,
+            references: normalizeContractStringList(params.references),
+            intent: "question",
+            needsResponse: true,
+          });
           const res = await fetch(`${identity.controllerUrl}/api/v1/messages/direct`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -44,6 +72,7 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
               toRole: targetRole,
               content: question,
               taskId: params.taskId ?? null,
+              contract,
             }),
           });
 
@@ -64,6 +93,11 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
       parameters: Type.Object({
         message: Type.String({ description: "The message to broadcast" }),
         taskId: Type.Optional(Type.String({ description: "Related task ID if any" })),
+        summary: Type.Optional(Type.String({ description: "Short structured summary for the broadcast" })),
+        details: Type.Optional(Type.String({ description: "Optional extra context for the team" })),
+        requestedAction: Type.Optional(Type.String({ description: "Optional action the team should take after reading this message" })),
+        needsResponse: Type.Optional(Type.Boolean({ description: "Whether the broadcast expects a response from recipients" })),
+        references: Type.Optional(Type.Array(Type.String({ description: "Relevant task IDs, file paths, or artifact references" }))),
       }),
       async execute(_id: string, params: Record<string, unknown>) {
         const identity = getIdentity();
@@ -77,6 +111,17 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         }
 
         try {
+          const contract = ensureTeamMessageContract(null, {
+            type: "broadcast",
+            content: message,
+            taskId: typeof params.taskId === "string" ? params.taskId : undefined,
+            summary: typeof params.summary === "string" ? params.summary : undefined,
+            details: typeof params.details === "string" ? params.details : undefined,
+            requestedAction: typeof params.requestedAction === "string" ? params.requestedAction : undefined,
+            needsResponse: typeof params.needsResponse === "boolean" ? params.needsResponse : undefined,
+            references: normalizeContractStringList(params.references),
+            intent: "announcement",
+          });
           const res = await fetch(`${identity.controllerUrl}/api/v1/messages/broadcast`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -85,6 +130,7 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
               fromRole: identity.role,
               content: message,
               taskId: params.taskId ?? null,
+              contract,
             }),
           });
 
@@ -106,6 +152,9 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         targetRole: Type.String({ description: "Exact target role ID to request review from" }),
         reviewContent: Type.String({ description: "Content to review or description of what needs review" }),
         taskId: Type.String({ description: "Related task ID" }),
+        summary: Type.Optional(Type.String({ description: "Short structured summary for the review request" })),
+        requestedAction: Type.Optional(Type.String({ description: "Concrete review action expected from the target role" })),
+        references: Type.Optional(Type.Array(Type.String({ description: "Relevant file paths, artifacts, or checks to review" }))),
       }),
       async execute(_id: string, params: Record<string, unknown>) {
         const identity = getIdentity();
@@ -122,6 +171,17 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         }
 
         try {
+          const contract = ensureTeamMessageContract(null, {
+            type: "review-request",
+            content: reviewContent,
+            toRole: normalizeContractRole(targetRole),
+            taskId,
+            summary: typeof params.summary === "string" ? params.summary : undefined,
+            requestedAction: typeof params.requestedAction === "string" ? params.requestedAction : undefined,
+            references: normalizeContractStringList(params.references),
+            intent: "review-request",
+            needsResponse: true,
+          });
           const res = await fetch(`${identity.controllerUrl}/api/v1/messages/review-request`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -131,6 +191,7 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
               toRole: targetRole,
               content: reviewContent,
               taskId,
+              contract,
             }),
           });
 
@@ -152,6 +213,9 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         taskId: Type.String({ description: "Task ID to hand off" }),
         targetRole: Type.String({ description: "Exact target role ID to hand off to" }),
         reason: Type.String({ description: "Reason for the handoff" }),
+        summary: Type.Optional(Type.String({ description: "Short structured summary for the handoff" })),
+        expectedNextStep: Type.Optional(Type.String({ description: "Concrete next step the receiving role should take" })),
+        artifacts: Type.Optional(Type.Array(Type.String({ description: "Files, task IDs, or artifacts the next role should inspect first" }))),
       }),
       async execute(_id: string, params: Record<string, unknown>) {
         const identity = getIdentity();
@@ -168,6 +232,13 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         }
 
         try {
+          const contract = normalizeTaskHandoffContract(null, {
+            targetRole: normalizeContractRole(targetRole),
+            reason,
+            summary: typeof params.summary === "string" ? params.summary : undefined,
+            expectedNextStep: typeof params.expectedNextStep === "string" ? params.expectedNextStep : undefined,
+            artifacts: normalizeContractStringList(params.artifacts),
+          });
           const res = await fetch(`${identity.controllerUrl}/api/v1/tasks/${taskId}/handoff`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -175,6 +246,7 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
               fromWorkerId: identity.workerId,
               targetRole,
               reason,
+              contract,
             }),
           });
 
@@ -188,6 +260,83 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         }
       },
     },
+    {
+      name: "teamclaw_submit_result_contract",
+      label: "Submit Result Contract",
+      description: "Record the structured completion/blocker contract for the current task before the final worker reply is returned",
+      parameters: Type.Object({
+        taskId: Type.String({ description: "Task ID" }),
+        outcome: Type.Optional(Type.String({ description: "Outcome: completed, blocked, or failed" })),
+        summary: Type.String({ description: "Short structured summary of the worker result" }),
+        deliverables: Type.Optional(
+          Type.Array(
+            Type.Object({
+              kind: Type.String({ description: "Deliverable kind: file, directory, command, artifact, or note" }),
+              value: Type.String({ description: "Deliverable identifier, path, or note" }),
+              summary: Type.Optional(Type.String({ description: "Optional short note about this deliverable" })),
+            }),
+          ),
+        ),
+        keyPoints: Type.Optional(Type.Array(Type.String({ description: "Important decisions, findings, or implementation notes" }))),
+        blockers: Type.Optional(Type.Array(Type.String({ description: "Any unresolved blockers or risks" }))),
+        followUps: Type.Optional(
+          Type.Array(
+            Type.Object({
+              type: Type.String({ description: "Follow-up type: review, handoff, clarification, downstream-task" }),
+              targetRole: Type.Optional(Type.String({ description: "Role that should handle the follow-up" })),
+              reason: Type.String({ description: "Why this follow-up is needed" }),
+            }),
+          ),
+        ),
+        questions: Type.Optional(Type.Array(Type.String({ description: "Any remaining open questions" }))),
+        notes: Type.Optional(Type.String({ description: "Optional extra delivery notes" })),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        const identity = getIdentity();
+        if (!identity) {
+          return { content: [{ type: "text" as const, text: "Not registered with a team." }] };
+        }
+
+        const taskId = String(params.taskId ?? "");
+        if (!taskId) {
+          return { content: [{ type: "text" as const, text: "taskId is required." }] };
+        }
+
+        const contract = normalizeWorkerTaskResultContract({
+          version: "1.0",
+          outcome: typeof params.outcome === "string" ? params.outcome : "completed",
+          summary: params.summary,
+          deliverables: params.deliverables,
+          keyPoints: params.keyPoints,
+          blockers: params.blockers,
+          followUps: params.followUps,
+          questions: params.questions,
+          notes: params.notes,
+        });
+        if (!contract) {
+          return { content: [{ type: "text" as const, text: "summary is required for teamclaw_submit_result_contract." }] };
+        }
+
+        try {
+          const res = await fetch(`${identity.controllerUrl}/api/v1/tasks/${taskId}/result-contract`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ contract, workerId: identity.workerId }),
+          });
+          if (!res.ok) {
+            return { content: [{ type: "text" as const, text: `Failed to submit result contract: ${res.status}` }] };
+          }
+          return {
+            content: [{
+              type: "text" as const,
+              text: `Result contract recorded for ${taskId}: ${contract.outcome} / ${contract.summary}`,
+            }],
+          };
+        } catch (err) {
+          return { content: [{ type: "text" as const, text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
+        }
+      },
+    },
     {
       name: "teamclaw_request_clarification",
       label: "Request Clarification",
@@ -267,8 +416,12 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
       description: "Report progress on an assigned task",
       parameters: Type.Object({
         taskId: Type.String({ description: "Task ID" }),
-        progress: Type.String({ description: "Progress update message" }),
+        progress: Type.Optional(Type.String({ description: "Progress update message" })),
         status: Type.Optional(Type.String({ description: "Optional non-terminal status: in_progress or review. Do not use completed or failed here." })),
+        summary: Type.Optional(Type.String({ description: "Short structured progress summary" })),
+        currentStep: Type.Optional(Type.String({ description: "What the worker is doing right now" })),
+        nextStep: Type.Optional(Type.String({ description: "What the worker plans to do next" })),
+        blockers: Type.Optional(Type.Array(Type.String({ description: "Any blockers slowing progress" }))),
       }),
       async execute(_id: string, params: Record<string, unknown>) {
         const identity = getIdentity();
@@ -277,12 +430,15 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         }
 
         const taskId = String(params.taskId ?? "");
-        const progress = String(params.progress ?? "");
+        const progress = typeof params.progress === "string" ? params.progress : "";
         const status = typeof params.status === "string" ? params.status : undefined;
 
         if (!taskId) {
           return { content: [{ type: "text" as const, text: "taskId is required." }] };
         }
+        if (!progress && typeof params.summary !== "string") {
+          return { content: [{ type: "text" as const, text: "progress or summary is required." }] };
+        }
         if (status && !ALLOWED_PROGRESS_STATUSES.has(status)) {
           return {
             content: [{
@@ -293,10 +449,23 @@ export function createWorkerTools(deps: WorkerToolsDeps) {
         }
 
         try {
-          const patch: Record<string, unknown> = { progress };
+          const progressContract = normalizeWorkerProgressContract({
+            version: "1.0",
+            summary: typeof params.summary === "string" ? params.summary : progress,
+            status,
+            currentStep: params.currentStep,
+            nextStep: params.nextStep,
+            blockers: params.blockers,
+          }) ?? backfillWorkerProgressContract(progress, status);
+          const patch: Record<string, unknown> = {
+            progress: renderWorkerProgressText(progressContract, progress),
+          };
           if (status) {
             patch.status = status;
           }
+          if (progressContract) {
+            patch.progressContract = progressContract;
+          }
 
           const res = await fetch(`${identity.controllerUrl}/api/v1/tasks/${taskId}`, {
             method: "PATCH",

package/src/worker/worker-service.ts

@@ -11,10 +11,10 @@ export type WorkerServiceDeps = {
   config: PluginConfig;
   logger: PluginLogger;
   onIdentityEstablished: (identity: WorkerIdentity) => void;
-  taskExecutor?: (taskDescription: string, taskId: string) => Promise<string>;
+  taskExecutor?: (taskDescription: string, assignment: TaskAssignmentPayload) => Promise<string>;
   prepareTaskAssignment?: (assignment: TaskAssignmentPayload) => Promise<void> | void;
   publishTaskAssignment?: (assignment: TaskAssignmentPayload, result: string) => Promise<void> | void;
-  cancelTaskExecution?: (taskId: string) => Promise<boolean> | boolean;
+  cancelTaskExecution?: (taskId: string, sessionKey?: string) => Promise<boolean> | boolean;
   messageQueue?: MessageQueue;
 };
 
@@ -27,6 +27,7 @@ export function createWorkerService(deps: WorkerServiceDeps): OpenClawPluginServ
   let controllerUrl: string | null = null;
   let workerId: string | null = null;
   let activeTaskId: string | undefined;
+  const activeTaskSessionKeys = new Map<string, string>();
   const cancelledTaskIds = new Set<string>();
 
   const taskExecutor = externalTaskExecutor
@@ -34,10 +35,11 @@ export function createWorkerService(deps: WorkerServiceDeps): OpenClawPluginServ
         const taskId = assignment.taskId;
         cancelledTaskIds.delete(taskId);
         activeTaskId = taskId;
+        activeTaskSessionKeys.set(taskId, assignment.executionSessionKey || `teamclaw-task-${taskId}`);
         try {
           await deps.prepareTaskAssignment?.(assignment);
           const taskPrompt = [assignment.title.trim(), assignment.description.trim()].filter(Boolean).join("\n\n");
-          const result = await externalTaskExecutor(taskPrompt, taskId);
+          const result = await externalTaskExecutor(taskPrompt, assignment);
           if (cancelledTaskIds.has(taskId)) {
             throw new Error("Task execution cancelled by controller");
           }
@@ -45,6 +47,7 @@ export function createWorkerService(deps: WorkerServiceDeps): OpenClawPluginServ
           return result;
         } finally {
           activeTaskId = undefined;
+          activeTaskSessionKeys.delete(taskId);
           if (!cancelledTaskIds.has(taskId)) {
             cancelledTaskIds.delete(taskId);
           }
@@ -74,7 +77,7 @@ export function createWorkerService(deps: WorkerServiceDeps): OpenClawPluginServ
 
     cancelledTaskIds.add(taskId);
     try {
-      const cancelled = await deps.cancelTaskExecution?.(taskId);
+      const cancelled = await deps.cancelTaskExecution?.(taskId, activeTaskSessionKeys.get(taskId));
       return cancelled ?? true;
     } catch (err) {
       logger.warn(`Worker: failed to cancel task ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
@@ -130,9 +133,9 @@ export function createWorkerService(deps: WorkerServiceDeps): OpenClawPluginServ
       } else {
         controllerUrl = identity.controllerUrl;
         workerId = identity.workerId;
+        onIdentityEstablished(identity);
         // Restart server with worker ID and task executor
         await startServer();
-        onIdentityEstablished(identity);
       }
 
       // Start heartbeat
@@ -142,8 +145,8 @@ export function createWorkerService(deps: WorkerServiceDeps): OpenClawPluginServ
           if (newIdentity && !controllerUrl) {
             controllerUrl = newIdentity.controllerUrl;
             workerId = newIdentity.workerId;
-            await startServer();
             onIdentityEstablished(newIdentity);
+            await startServer();
           }
           return;
         }