@markus-global/cli 0.6.3 → 0.6.5

package/dist/markus.mjs

@@ -6381,20 +6381,80 @@ var init_context_engine = __esm({
         this.llmSummarizer = summarizer;
       }
       async buildSystemPrompt(opts) {
-        const parts = [];
-        parts.push(opts.role.systemPrompt);
-        if (opts.dynamicContext) {
-          parts.push(opts.dynamicContext);
+        const isDream = opts.scenario === "memory_consolidation";
+        const stable = [];
+        stable.push(opts.role.systemPrompt);
+        if (opts.role.defaultPolicies.length > 0) {
+          stable.push("\n## Policies");
+          for (const policy of opts.role.defaultPolicies) {
+            stable.push(`### ${policy.name}`);
+            for (const rule of policy.rules) {
+              stable.push(`- ${rule}`);
+            }
+          }
+        }
+        if (!isDream) {
+          stable.push("\n## Tool Usage Rules");
+          stable.push("**File editing discipline**: You MUST use `file_write` and `file_edit` for all file creation and modification. NEVER use `shell_execute` with `cat`, `echo`, `printf`, `tee`, pipes (`|`), output redirection (`>`, `>>`), heredocs (`<<`), or `sed`/`awk` to write or modify files \u2014 these bypass file access controls. `shell_execute` is for running commands (build, test, git, etc.), not for writing files.");
+          stable.push("**Large file writing**: NEVER write a document >200 lines in a single `file_write` call. Write section by section: `file_write` the first section, then `file_edit` to append each subsequent section.");
+          stable.push("**Error handling**: If a tool call fails, analyze the error and try a different approach \u2014 do NOT repeat the same failing action.");
+          stable.push("**Subagent delegation**: For heavy subtasks needing many tool calls or lots of file reading, delegate to `spawn_subagent` to keep your context lean. Use `spawn_subagents` to run independent subtasks in parallel.");
+          stable.push("**Built-in tools over CLI**: ALWAYS prefer built-in tools (`task_create`, `task_assign`, `team_hire_agent`, `builder_install`, `agent_send_message`, `memory_save`, etc.) over running `markus` CLI commands via `shell_execute`. The CLI is for human operators \u2014 agents must use their native tool interface. Only fall back to CLI if no built-in tool exists for the operation.");
+          stable.push('**No auto-install/deploy**: NEVER automatically install or deploy agents, teams, or skills via `builder_install`, `team_hire_agent`, or `hub_install` unless explicitly requested by a human team member (e.g., "install", "deploy", "hire", "start"). Creating an artifact (writing files to `builder-artifacts/`) is separate from deploying it into the live organization.');
+          stable.push("");
+          stable.push("\n## Task & Requirement Workflow");
+          stable.push("");
+          stable.push("**Requirements** (governance gate):");
+          stable.push("- `requirement_propose` \u2192 pending human approval \u2192 approved \u2192 link tasks via `requirement_id`");
+          stable.push("- Every task MUST reference an approved `requirement_id`. Use `requirement_propose` first if no requirement exists.");
+          stable.push("");
+          stable.push("**Task lifecycle** \u2014 Create \u2192 Execute \u2192 Review \u2192 Complete:");
+          stable.push('- **Create**: `task_create` (REQUIRED: `assigned_agent_id`, `reviewer_id`; optional `reviewer_type`: "agent"|"human"). Check `task_list` first to avoid duplicates.');
+          stable.push("- **Execute**: Decompose with `subtask_create` \u2192 work through subtasks \u2192 `task_submit_review` with summary + deliverables (MANDATORY). System auto-fills `task_id` and `reviewer`.");
+          stable.push('- **Review**: Reviewer approves with `task_update(status:"completed")` or rejects with `task_update(status:"in_progress", note:"what needs to change")` (auto-restarts execution). Workers MUST NOT set status=completed on their own tasks.');
+          stable.push('- **Blockers**: Use `task_update(status:"blocked", note:"reason")` when unable to proceed.');
+          stable.push("");
+          stable.push("**Dependencies & DAG decomposition**:");
+          stable.push("- **CRITICAL**: Use `blocked_by` to express ALL dependency relationships. If task B needs output from task A, B **MUST** include A's ID in `blocked_by`. Without this, tasks run in parallel and downstream tasks lack upstream deliverables.");
+          stable.push("- For complex goals, create a DAG of tasks. Assign each to the best team member (`team_list`). Independent tasks run in parallel; dependent tasks wait for predecessors.");
+          stable.push("- If consolidated output is needed, create a final synthesis task assigned to a manager, `blocked_by` ALL prerequisites.");
+          stable.push("");
+          stable.push("**Work discovery**: `list_projects` \u2192 `requirement_list` \u2192 `task_list`. Use `memory_save`/`memory_search` for personal notes; `deliverable_create`/`deliverable_search` for shared outputs.");
+          stable.push("");
+          stable.push("**Automatic status notifications** (do NOT duplicate manually):");
+          stable.push("- When task status changes, the system **automatically** handles all side effects: execution start/cancel, reviewer notification, dependency unblocking.");
+          stable.push("- Task status notifications are placed in assignees' mailboxes as **informational context only**.");
+          stable.push("- Do NOT send A2A messages to notify about task status changes \u2014 only send A2A when you have substantive coordination needs beyond the status change itself.");
+          stable.push("");
+          stable.push("**Communicating with humans**:");
+          stable.push("- `notify_user` \u2014 proactive message to a human team member: status updates, progress reports, findings, alerts. Appears in chat timeline AND notification bell. The human can reply. Write comprehensive body with full context. **This is the ONLY way to reach humans from non-chat contexts** (heartbeat, autonomous tasks, etc.).");
+          stable.push("- `request_user_approval` \u2014 when you need a human decision, approval, or input. BLOCKS until the user responds. Supports custom options and freeform text. Do NOT use for routine updates.");
+          stable.push("- `recall_activity` \u2014 query your own past execution logs by task or activity type. Use when you need to review what you did previously (e.g., to answer a follow-up question).");
+          stable.push("");
+          stable.push("**Communicating with other agents**:");
+          stable.push("- `agent_send_message` \u2014 send a direct message to a peer agent. **By default this is asynchronous (fire-and-forget)**: the message enters their mailbox and you continue working without waiting. Set `wait_for_reply: true` only when you need the answer before you can proceed (rare \u2014 prefer async).");
+          stable.push("- A2A messaging is inherently **non-blocking**. You send a message, the recipient processes it on their own schedule, and may reply later via their own `agent_send_message`. Do NOT spin-wait or poll for responses.");
+          stable.push("- For substantial work requests, create a `task_create` assigned to the target agent instead of asking via message.");
+          stable.push("- Do NOT use A2A messages for routine task status notifications \u2014 the system handles those automatically.");
         }
-        parts.push(this.buildIdentitySection(opts));
+        const scenario = opts.scenario ?? "chat";
+        stable.push(this.buildScenarioSection(scenario, { a2aWaitForReply: opts.a2aWaitForReply }));
+        const semiStable = [];
+        semiStable.push(this.buildIdentitySection({
+          agentId: opts.agentId,
+          agentName: opts.agentName,
+          role: opts.role,
+          identity: opts.identity,
+          availableSkills: opts.availableSkills
+        }));
         const orgCtx = this.buildOrgContextSection(opts.orgContext, opts.contextMdPath);
         if (orgCtx)
-          parts.push(orgCtx);
+          semiStable.push(orgCtx);
         if (opts.teamAnnouncements?.trim()) {
-          parts.push("\n## Team Announcements\n" + opts.teamAnnouncements.trim());
+          semiStable.push("\n## Team Announcements\n" + opts.teamAnnouncements.trim());
         }
         if (opts.teamNorms?.trim()) {
-          parts.push("\n## Team Working Norms\n" + opts.teamNorms.trim());
+          semiStable.push("\n## Team Working Norms\n" + opts.teamNorms.trim());
         }
         if (opts.teamDataDir) {
           const lines = ["\n## Team Data Directory", `Path: \`${opts.teamDataDir}\``, "Files:", "- `ANNOUNCEMENT.md` \u2014 team announcements", "- `NORMS.md` \u2014 team working norms"];
@@ -6403,50 +6463,32 @@ var init_context_engine = __esm({
           } else {
             lines.push("\nRead and follow the announcements and norms above. If you need changes, ask the team manager.");
           }
-          parts.push(lines.join("\n"));
-        }
-        if (opts.projectContext) {
-          const { project, repositories, governanceRules, teamRole } = opts.projectContext;
-          parts.push("\n## Current Project");
-          parts.push(`- Project: **${project.name}** (${project.status})`);
-          if (project.description)
-            parts.push(`- ${project.description.slice(0, SYSTEM_PROJECT_DESC_CHARS)}`);
-          if (repositories?.length) {
-            for (const repo of repositories) {
-              parts.push(`- Repository: \`${repo.localPath}\` (${repo.role}, default branch: \`${repo.defaultBranch}\`)`);
-            }
-          }
-          parts.push("");
-          parts.push("Some git operations (switching to existing branches, pushing to protected branches, merge, rebase) require human approval \u2014 the system will pause and ask the reviewer. If denied, you will receive a reason; read it and adjust your approach.");
-          if (teamRole)
-            parts.push(`- Your role: ${teamRole}`);
-          if (governanceRules)
-            parts.push(`- Governance: ${governanceRules}`);
+          semiStable.push(lines.join("\n"));
         }
         if (opts.agentWorkspace) {
-          parts.push("\n## Your Workspace");
-          parts.push(`- Working directory: \`${opts.agentWorkspace.primaryWorkspace}\``);
+          semiStable.push("\n## Your Workspace");
+          semiStable.push(`- Working directory: \`${opts.agentWorkspace.primaryWorkspace}\``);
           if (opts.agentWorkspace.sharedWorkspace) {
-            parts.push(`- Shared workspace: \`${opts.agentWorkspace.sharedWorkspace}\` (all agents can read/write here)`);
+            semiStable.push(`- Shared workspace: \`${opts.agentWorkspace.sharedWorkspace}\` (all agents can read/write here)`);
           }
           const artifactsDir = opts.agentWorkspace.builderArtifactsDir ?? "~/.markus/builder-artifacts";
           if (opts.agentWorkspace.builderArtifactsDir) {
-            parts.push(`- Builder artifacts directory: \`${artifactsDir}/\``);
-            parts.push("  When creating agents, teams, or skills, place them in the correct subdirectory:");
-            parts.push(`  - Agents \u2192 \`${artifactsDir}/agents/{agent-name}/\``);
-            parts.push(`  - Teams \u2192 \`${artifactsDir}/teams/{team-name}/\``);
-            parts.push(`  - Skills \u2192 \`${artifactsDir}/skills/{skill-name}/\``);
-            parts.push("  The Builder page and install system ONLY recognize these paths.");
+            semiStable.push(`- Builder artifacts directory: \`${artifactsDir}/\``);
+            semiStable.push("  When creating agents, teams, or skills, place them in the correct subdirectory:");
+            semiStable.push(`  - Agents \u2192 \`${artifactsDir}/agents/{agent-name}/\``);
+            semiStable.push(`  - Teams \u2192 \`${artifactsDir}/teams/{team-name}/\``);
+            semiStable.push(`  - Skills \u2192 \`${artifactsDir}/skills/{skill-name}/\``);
+            semiStable.push("  The Builder page and install system ONLY recognize these paths.");
           }
           if (opts.agentDataDir) {
-            parts.push(`- Agent data directory: \`${opts.agentDataDir}\` (your ROLE.md, MEMORY.md, and personal files)`);
+            semiStable.push(`- Agent data directory: \`${opts.agentDataDir}\` (your ROLE.md, MEMORY.md, and personal files)`);
           }
-          parts.push("- IMPORTANT: Always use **absolute paths** in file operations. Relative paths are error-prone.");
-          parts.push("- You can directly read files in the shared workspace using `file_read` \u2014 no need to request them from other agents.");
+          semiStable.push("- IMPORTANT: Always use **absolute paths** in file operations. Relative paths are error-prone.");
+          semiStable.push("- You can directly read files in the shared workspace using `file_read` \u2014 no need to request them from other agents.");
         } else if (opts.agentDataDir) {
-          parts.push("\n## Your Workspace");
-          parts.push(`- Agent data directory: \`${opts.agentDataDir}\` (your ROLE.md, MEMORY.md, and personal files)`);
-          parts.push("- IMPORTANT: Always use **absolute paths** in file operations. Relative paths are error-prone.");
+          semiStable.push("\n## Your Workspace");
+          semiStable.push(`- Agent data directory: \`${opts.agentDataDir}\` (your ROLE.md, MEMORY.md, and personal files)`);
+          semiStable.push("- IMPORTANT: Always use **absolute paths** in file operations. Relative paths are error-prone.");
         }
         if (opts.agentWorkspace?.sharedWorkspace) {
           const userMdPath = `${opts.agentWorkspace.sharedWorkspace}/USER.md`;
@@ -6454,206 +6496,186 @@ var init_context_engine = __esm({
             if (existsSync8(userMdPath)) {
               const userProfile = readFileSync6(userMdPath, "utf-8").trim();
               if (userProfile) {
-                parts.push("\n## About the Owner");
-                parts.push(userProfile.slice(0, SYSTEM_USER_PROFILE_CHARS));
-                parts.push("\n_This profile is maintained by the Secretary. If you notice new preferences or patterns from the owner, mention them to the Secretary via `agent_send_message`._");
+                semiStable.push("\n## About the Owner");
+                semiStable.push(userProfile.slice(0, SYSTEM_USER_PROFILE_CHARS));
+                semiStable.push("\n_This profile is maintained by the Secretary. If you notice new preferences or patterns from the owner, mention them to the Secretary via `agent_send_message`._");
               }
             }
           } catch {
           }
         }
         if (opts.trustLevel) {
-          parts.push("\n## Your Trust Level");
-          parts.push(`- Level: **${opts.trustLevel.level}** (score: ${opts.trustLevel.score})`);
+          semiStable.push("\n## Your Trust Level");
+          semiStable.push(`- Level: **${opts.trustLevel.level}** (score: ${opts.trustLevel.score})`);
           if (opts.trustLevel.level === "probation") {
-            parts.push("- You are on probation. All your task creations require human approval. Focus on quality to build trust.");
+            semiStable.push("- You are on probation. All your task creations require human approval. Focus on quality to build trust.");
           } else if (opts.trustLevel.level === "standard") {
-            parts.push("- You are a standard-level agent. Routine tasks may auto-approve; significant tasks need manager approval.");
+            semiStable.push("- You are a standard-level agent. Routine tasks may auto-approve; significant tasks need manager approval.");
           } else if (opts.trustLevel.level === "trusted") {
-            parts.push("- You are a trusted agent. You have a proven track record and higher autonomy.");
+            semiStable.push("- You are a trusted agent. You have a proven track record and higher autonomy.");
           } else if (opts.trustLevel.level === "senior") {
-            parts.push("- You are a senior agent. You have the highest autonomy. Routine tasks auto-approve.");
+            semiStable.push("- You are a senior agent. You have the highest autonomy. Routine tasks auto-approve.");
+          }
+        }
+        if (opts.environment) {
+          semiStable.push(this.buildEnvironmentSection(opts.environment));
+        }
+        const longTermMem = opts.memory.getLongTermMemory();
+        if (longTermMem) {
+          semiStable.push("\n## Your Knowledge");
+          semiStable.push(longTermMem.slice(0, SYSTEM_KNOWLEDGE_CHARS));
+        }
+        const dynamic = [];
+        if (opts.projectContext) {
+          const { project, repositories, governanceRules, teamRole } = opts.projectContext;
+          dynamic.push("\n## Current Project");
+          dynamic.push(`- Project: **${project.name}** (${project.status})`);
+          if (project.description)
+            dynamic.push(`- ${project.description.slice(0, SYSTEM_PROJECT_DESC_CHARS)}`);
+          if (repositories?.length) {
+            for (const repo of repositories) {
+              dynamic.push(`- Repository: \`${repo.localPath}\` (${repo.role}, default branch: \`${repo.defaultBranch}\`)`);
+            }
           }
+          dynamic.push("");
+          dynamic.push("Some git operations (switching to existing branches, pushing to protected branches, merge, rebase) require human approval \u2014 the system will pause and ask the reviewer. If denied, you will receive a reason; read it and adjust your approach.");
+          if (teamRole)
+            dynamic.push(`- Your role: ${teamRole}`);
+          if (governanceRules)
+            dynamic.push(`- Governance: ${governanceRules}`);
         }
         if (opts.announcements?.length) {
-          parts.push("\n## System Announcements");
+          dynamic.push("\n## System Announcements");
           for (const a of opts.announcements) {
             const prefix = a.priority === "urgent" ? "[URGENT] " : a.priority === "high" ? "[HIGH] " : "[INFO] ";
-            parts.push(`- ${prefix}${a.title}: ${a.content}`);
+            dynamic.push(`- ${prefix}${a.title}: ${a.content}`);
           }
         }
         if (opts.recentFeedback?.length) {
-          parts.push("\n## Human Feedback (recent)");
+          dynamic.push("\n## Human Feedback (recent)");
           for (const fb of opts.recentFeedback) {
             const urgency = fb.priority === "critical" ? "[CRITICAL] " : fb.priority === "important" ? "[IMPORTANT] " : "";
             const anchor = fb.anchor ? ` (re: ${fb.anchor.section}${fb.anchor.itemId ? "/" + fb.anchor.itemId : ""})` : "";
-            parts.push(`- ${urgency}**${fb.authorName}**${anchor}: ${fb.content}`);
+            dynamic.push(`- ${urgency}**${fb.authorName}**${anchor}: ${fb.content}`);
           }
         }
         if (opts.projectDeliverables?.length) {
-          parts.push("\n## Project Deliverables (key entries)");
+          dynamic.push("\n## Project Deliverables (key entries)");
           for (const k of opts.projectDeliverables) {
-            parts.push(`- **[${k.category}]** ${k.title}: ${k.content.slice(0, SYSTEM_DELIVERABLE_PREVIEW_CHARS)}`);
+            dynamic.push(`- **[${k.category}]** ${k.title}: ${k.content.slice(0, SYSTEM_DELIVERABLE_PREVIEW_CHARS)}`);
           }
         }
-        if (opts.role.defaultPolicies.length > 0) {
-          parts.push("\n## Policies");
-          for (const policy of opts.role.defaultPolicies) {
-            parts.push(`### ${policy.name}`);
-            for (const rule of policy.rules) {
-              parts.push(`- ${rule}`);
-            }
-          }
-        }
-        const longTermMem = opts.memory.getLongTermMemory();
-        if (longTermMem) {
-          parts.push("\n## Your Knowledge");
-          parts.push(longTermMem.slice(0, SYSTEM_KNOWLEDGE_CHARS));
-        }
-        const alreadyShownIds = /* @__PURE__ */ new Set();
-        const isDream = opts.scenario === "memory_consolidation";
         if (!isDream && (opts.deliverableContext || opts.knowledgeContext)) {
-          parts.push("\n## Shared Deliverables");
-          parts.push((opts.deliverableContext ?? opts.knowledgeContext ?? "").slice(0, SYSTEM_DELIVERABLES_CHARS));
-        }
-        const cpp = opts.cognitiveContext;
-        if (cpp && !cpp.isEmpty) {
-          if (cpp.cognitiveContext) {
-            parts.push("\n## Cognitive Context");
-            parts.push(cpp.cognitiveContext);
-          }
-          if (cpp.retrievedContext) {
-            parts.push("\n## Retrieved Context");
-            parts.push(cpp.retrievedContext);
-          }
-          if (cpp.reflection) {
-            parts.push("\n## Reflection");
-            parts.push(cpp.reflection);
-          }
-        } else if (!isDream) {
-          const relevantMemories = await this.retrieveRelevantMemories(opts.memory, opts.currentQuery, opts.agentId, alreadyShownIds);
-          if (relevantMemories.length > 0) {
-            parts.push("\n## Relevant Memories");
-            for (const mem of relevantMemories) {
-              const ts = mem.timestamp ? new Date(mem.timestamp).toLocaleDateString() : "";
-              parts.push(`- [${ts}] ${mem.content}`);
-            }
-          }
+          dynamic.push("\n## Shared Deliverables");
+          dynamic.push((opts.deliverableContext ?? opts.knowledgeContext ?? "").slice(0, SYSTEM_DELIVERABLES_CHARS));
         }
         if (!isDream) {
           if (opts.assignedTasks && opts.assignedTasks.length > 0) {
             const priorityOrder = ["critical", "high", "medium", "low"];
             const byPriority = (a, b) => priorityOrder.indexOf(a.priority ?? "medium") - priorityOrder.indexOf(b.priority ?? "medium");
+            const CLOSED_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "failed", "archived", "rejected"]);
             const myTasks = opts.assignedTasks.filter((t) => t.assignedAgentId === opts.agentId);
             const otherTasks = opts.assignedTasks.filter((t) => t.assignedAgentId !== opts.agentId);
-            const myActive = myTasks.filter((t) => !["completed", "cancelled", "failed"].includes(t.status)).sort(byPriority);
-            const myDone = myTasks.filter((t) => ["completed", "cancelled", "failed"].includes(t.status));
+            const myActive = myTasks.filter((t) => !CLOSED_STATUSES.has(t.status)).sort(byPriority);
+            const myDone = myTasks.filter((t) => CLOSED_STATUSES.has(t.status));
             const MY_TASK_LIMIT = SYSTEM_MY_TASKS_MAX;
             const TEAM_TASK_LIMIT = SYSTEM_TEAM_TASKS_MAX;
-            parts.push("\n## Task Board");
-            parts.push("### My Tasks (assigned to you):");
+            dynamic.push("\n## Task Board");
+            dynamic.push("### My Tasks (assigned to you):");
             if (myActive.length > 0) {
               const shown = myActive.slice(0, MY_TASK_LIMIT);
               for (const t of shown) {
-                parts.push(`- [${t.status.toUpperCase()}] **${t.title}** (ID: \`${t.id}\`, priority: ${t.priority})`);
+                dynamic.push(`- [${t.status.toUpperCase()}] **${t.title}** (ID: \`${t.id}\`, priority: ${t.priority})`);
                 if (t.description)
-                  parts.push(`  ${t.description.slice(0, SYSTEM_TASK_DESC_CHARS)}`);
+                  dynamic.push(`  ${t.description.slice(0, SYSTEM_TASK_DESC_CHARS)}`);
               }
               if (myActive.length > MY_TASK_LIMIT) {
-                parts.push(`_(${myActive.length - MY_TASK_LIMIT} more active tasks not shown \u2014 use \`task_list\` for full list)_`);
+                dynamic.push(`_(${myActive.length - MY_TASK_LIMIT} more active tasks not shown \u2014 use \`task_list\` for full list)_`);
               }
             } else {
-              parts.push("No active tasks assigned to you.");
+              dynamic.push("No active tasks assigned to you.");
             }
             if (myDone.length > 0) {
-              parts.push(`_(${myDone.length} completed/closed tasks)_`);
+              dynamic.push(`_(${myDone.length} completed/closed tasks)_`);
             }
             if (otherTasks.length > 0) {
-              const otherActive = otherTasks.filter((t) => !["completed", "cancelled", "failed"].includes(t.status)).sort(byPriority);
-              const otherDone = otherTasks.filter((t) => ["completed", "cancelled", "failed"].includes(t.status));
+              const otherActive = otherTasks.filter((t) => !CLOSED_STATUSES.has(t.status)).sort(byPriority);
+              const otherDone = otherTasks.filter((t) => CLOSED_STATUSES.has(t.status));
               if (otherActive.length > 0) {
-                parts.push("### Team Tasks (assigned to others):");
+                dynamic.push("### Team Tasks (assigned to others):");
                 const shown = otherActive.slice(0, TEAM_TASK_LIMIT);
                 for (const t of shown) {
                   const owner = t.assignedAgentName ?? t.assignedAgentId ?? "unassigned";
-                  parts.push(`- [${t.status.toUpperCase()}] **${t.title}** (ID: \`${t.id}\`, assignee: ${owner}, priority: ${t.priority})`);
+                  dynamic.push(`- [${t.status.toUpperCase()}] **${t.title}** (ID: \`${t.id}\`, assignee: ${owner}, priority: ${t.priority})`);
                 }
                 if (otherActive.length > TEAM_TASK_LIMIT) {
-                  parts.push(`_(${otherActive.length - TEAM_TASK_LIMIT} more team tasks not shown)_`);
+                  dynamic.push(`_(${otherActive.length - TEAM_TASK_LIMIT} more team tasks not shown)_`);
                 }
               }
               if (otherDone.length > 0) {
-                parts.push(`_(${otherDone.length} other completed/closed tasks)_`);
+                dynamic.push(`_(${otherDone.length} other completed/closed tasks)_`);
               }
             }
           } else {
-            parts.push("\n## Task Board");
-            parts.push("No tasks on the board.");
+            dynamic.push("\n## Task Board");
+            dynamic.push("No tasks on the board.");
           }
-          parts.push("");
-          parts.push("### Task & Requirement Workflow");
-          parts.push("");
-          parts.push("**Requirements** (governance gate):");
-          parts.push("- `requirement_propose` \u2192 pending human approval \u2192 approved \u2192 link tasks via `requirement_id`");
-          parts.push("- When governance requires it, every task MUST reference an approved `requirement_id`.");
-          parts.push("");
-          parts.push("**Task lifecycle** \u2014 Create \u2192 Execute \u2192 Review \u2192 Complete:");
-          parts.push('- **Create**: `task_create` (REQUIRED: `assigned_agent_id`, `reviewer_id`; optional `reviewer_type`: "agent"|"human"). Check `task_list` first to avoid duplicates.');
-          parts.push("- **Execute**: Decompose with `subtask_create` \u2192 work through subtasks \u2192 `task_submit_review` with summary + deliverables (MANDATORY). System auto-fills `task_id` and `reviewer`.");
-          parts.push('- **Review**: Reviewer approves with `task_update(status:"completed")` or rejects with `task_update(status:"in_progress", note:"what needs to change")` (auto-restarts execution). Workers MUST NOT set status=completed on their own tasks.');
-          parts.push('- **Blockers**: Use `task_update(status:"blocked", note:"reason")` when unable to proceed.');
-          parts.push("");
-          parts.push("**Dependencies & DAG decomposition**:");
-          parts.push("- **CRITICAL**: Use `blocked_by` to express ALL dependency relationships. If task B needs output from task A, B **MUST** include A's ID in `blocked_by`. Without this, tasks run in parallel and downstream tasks lack upstream deliverables.");
-          parts.push("- For complex goals, create a DAG of tasks. Assign each to the best team member (`team_list`). Independent tasks run in parallel; dependent tasks wait for predecessors.");
-          parts.push("- If consolidated output is needed, create a final synthesis task assigned to a manager, `blocked_by` ALL prerequisites.");
-          parts.push("");
-          parts.push("**Work discovery**: `list_projects` \u2192 `requirement_list` \u2192 `task_list`. Use `memory_save`/`memory_search` for personal notes; `deliverable_create`/`deliverable_search` for shared outputs.");
-          parts.push("");
-          parts.push("**Automatic status notifications** (do NOT duplicate manually):");
-          parts.push("- When task status changes, the system **automatically** handles all side effects: execution start/cancel, reviewer notification, dependency unblocking.");
-          parts.push("- Task status notifications are placed in assignees' mailboxes as **informational context only**.");
-          parts.push("- Do NOT send A2A messages to notify about task status changes \u2014 only send A2A when you have substantive coordination needs beyond the status change itself.");
-          parts.push("");
-          parts.push("**Communicating with humans**:");
-          parts.push("- `notify_user` \u2014 proactive message to a human team member: status updates, progress reports, findings, alerts. Appears in chat timeline AND notification bell. The human can reply. Write comprehensive body with full context. **This is the ONLY way to reach humans from non-chat contexts** (heartbeat, autonomous tasks, etc.).");
-          parts.push("- `request_user_approval` \u2014 when you need a human decision, approval, or input. BLOCKS until the user responds. Supports custom options and freeform text. Do NOT use for routine updates.");
-          parts.push("- `recall_activity` \u2014 query your own past execution logs by task or activity type. Use when you need to review what you did previously (e.g., to answer a follow-up question).");
-          parts.push("");
-          parts.push("**Communicating with other agents**:");
-          parts.push("- `agent_send_message` \u2014 send a direct message to a peer agent. Use for coordination, questions, sharing context, or instructions. The message enters their mailbox and they will process it.");
-          parts.push("- For substantial work requests, create a `task_create` assigned to the target agent instead of asking via message.");
-          parts.push("- Do NOT use A2A messages for routine task status notifications \u2014 the system handles those automatically.");
         }
-        if (opts.environment) {
-          parts.push(this.buildEnvironmentSection(opts.environment));
+        if (opts.dynamicContext) {
+          dynamic.push(opts.dynamicContext);
+        }
+        const alreadyShownIds = /* @__PURE__ */ new Set();
+        const cpp = opts.cognitiveContext;
+        if (cpp && !cpp.isEmpty) {
+          if (cpp.cognitiveContext) {
+            dynamic.push("\n## Cognitive Context");
+            dynamic.push(cpp.cognitiveContext);
+          }
+          if (cpp.retrievedContext) {
+            dynamic.push("\n## Retrieved Context");
+            dynamic.push(cpp.retrievedContext);
+          }
+          if (cpp.reflection) {
+            dynamic.push("\n## Reflection");
+            dynamic.push(cpp.reflection);
+          }
+        } else if (!isDream) {
+          const relevantMemories = await this.retrieveRelevantMemories(opts.memory, opts.currentQuery, opts.agentId, alreadyShownIds);
+          if (relevantMemories.length > 0) {
+            dynamic.push("\n## Relevant Memories");
+            for (const mem of relevantMemories) {
+              const ts = mem.timestamp ? new Date(mem.timestamp).toLocaleDateString() : "";
+              dynamic.push(`- [${ts}] ${mem.content}`);
+            }
+          }
+        }
+        if (!isDream && opts.mailboxContext) {
+          dynamic.push(this.buildMailboxSection(opts.mailboxContext));
         }
         if (!isDream && opts.senderIdentity) {
-          parts.push(`
+          dynamic.push(`
 ## Current Conversation`);
-          parts.push(`You are now talking to **${opts.senderIdentity.name}** (${opts.senderIdentity.role}).`);
+          dynamic.push(`You are now talking to **${opts.senderIdentity.name}** (${opts.senderIdentity.role}).`);
+          if (opts.senderIdentity.isFirstConversation) {
+            dynamic.push("**This is their first conversation** \u2014 they have never used Markus before. Follow your onboarding protocol if you have one.");
+          }
           if (opts.senderIdentity.role === "owner") {
-            parts.push("This person is the organization owner. Their instructions have the highest priority. Be proactive in reporting and responsive to their needs.");
+            dynamic.push("This person is the organization owner. Their instructions have the highest priority. Be proactive in reporting and responsive to their needs.");
           } else if (opts.senderIdentity.role === "admin") {
-            parts.push("This person is an administrator. Cooperate actively and share progress proactively.");
+            dynamic.push("This person is an administrator. Cooperate actively and share progress proactively.");
           } else if (opts.senderIdentity.role === "guest") {
-            parts.push("This person is an external guest. Be polite but cautious \u2014 do not expose internal sensitive information.");
+            dynamic.push("This person is an external guest. Be polite but cautious \u2014 do not expose internal sensitive information.");
           }
         }
         if (!isDream) {
-          parts.push("\n## Tool Usage Rules");
-          parts.push("**File editing discipline**: You MUST use `file_write` and `file_edit` for all file creation and modification. NEVER use `shell_execute` with `cat`, `echo`, `printf`, `tee`, pipes (`|`), output redirection (`>`, `>>`), heredocs (`<<`), or `sed`/`awk` to write or modify files \u2014 these bypass file access controls. `shell_execute` is for running commands (build, test, git, etc.), not for writing files.");
-          parts.push("**Large file writing**: NEVER write a document >200 lines in a single `file_write` call. Write section by section: `file_write` the first section, then `file_edit` to append each subsequent section.");
-          parts.push("**Error handling**: If a tool call fails, analyze the error and try a different approach \u2014 do NOT repeat the same failing action.");
-          parts.push("**Subagent delegation**: For heavy subtasks needing many tool calls or lots of file reading, delegate to `spawn_subagent` to keep your context lean. Use `spawn_subagents` to run independent subtasks in parallel.");
-          parts.push("**Built-in tools over CLI**: ALWAYS prefer built-in tools (`task_create`, `task_assign`, `team_hire_agent`, `builder_install`, `agent_send_message`, `memory_save`, etc.) over running `markus` CLI commands via `shell_execute`. The CLI is for human operators \u2014 agents must use their native tool interface. Only fall back to CLI if no built-in tool exists for the operation.");
-          parts.push('**No auto-install/deploy**: NEVER automatically install or deploy agents, teams, or skills via `builder_install`, `team_hire_agent`, or `hub_install` unless explicitly requested by a human team member (e.g., "install", "deploy", "hire", "start"). Creating an artifact (writing files to `builder-artifacts/`) is separate from deploying it into the live organization.');
+          dynamic.push("\n## Tool Usage Rules");
+          dynamic.push("**File editing discipline**: You MUST use `file_write` and `file_edit` for all file creation and modification. NEVER use `shell_execute` with `cat`, `echo`, `printf`, `tee`, pipes (`|`), output redirection (`>`, `>>`), heredocs (`<<`), or `sed`/`awk` to write or modify files \u2014 these bypass file access controls. `shell_execute` is for running commands (build, test, git, etc.), not for writing files.");
+          dynamic.push("**Large file writing**: NEVER write a document >200 lines in a single `file_write` call. Write section by section: `file_write` the first section, then `file_edit` to append each subsequent section.");
+          dynamic.push("**Error handling**: If a tool call fails, analyze the error and try a different approach \u2014 do NOT repeat the same failing action.");
+          dynamic.push("**Subagent delegation**: For heavy subtasks needing many tool calls or lots of file reading, delegate to `spawn_subagent` to keep your context lean. Use `spawn_subagents` to run independent subtasks in parallel.");
+          dynamic.push("**Built-in tools over CLI**: ALWAYS prefer built-in tools (`task_create`, `task_assign`, `package_install`, `agent_send_message`, `memory_save`, etc.) over running `markus` CLI commands via `shell_execute`. The CLI is for human operators \u2014 agents must use their native tool interface. Only fall back to CLI if no built-in tool exists for the operation.");
+          dynamic.push('**No auto-install/deploy**: NEVER automatically install or deploy agents, teams, or skills via `package_install` or `hub_install` unless explicitly requested by a human team member (e.g., "install", "deploy", "hire", "start"). Creating an artifact (writing files to `builder-artifacts/`) is separate from deploying it into the live organization.');
         }
-        if (!isDream && opts.mailboxContext) {
-          parts.push(this.buildMailboxSection(opts.mailboxContext));
-        }
-        const scenario = opts.scenario ?? "chat";
-        parts.push(this.buildScenarioSection(scenario, { a2aWaitForReply: opts.a2aWaitForReply }));
         const now2 = /* @__PURE__ */ new Date();
         const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
         const offset = now2.getTimezoneOffset();
@@ -6662,10 +6684,23 @@ var init_context_engine = __esm({
         const absM = String(Math.abs(offset) % 60).padStart(2, "0");
         const pad = (n) => String(n).padStart(2, "0");
         const localStr = `${now2.getFullYear()}-${pad(now2.getMonth() + 1)}-${pad(now2.getDate())} ${pad(now2.getHours())}:${pad(now2.getMinutes())}:${pad(now2.getSeconds())}`;
-        parts.push(`
+        dynamic.push(`
 ---
 Current date and time: ${localStr} (${tz}, UTC${sign}${absH}:${absM})`);
-        return parts.join("\n");
+        const stableText = stable.join("\n");
+        const semiStableText = semiStable.join("\n");
+        const dynamicText = dynamic.join("\n");
+        const segments = [];
+        if (stableText)
+          segments.push({ content: stableText, cacheBreakpoint: true });
+        if (semiStableText)
+          segments.push({ content: semiStableText, cacheBreakpoint: true });
+        if (dynamicText)
+          segments.push({ content: dynamicText });
+        return {
+          text: segments.map((s) => s.content).join("\n"),
+          segments
+        };
       }
       buildMailboxSection(ctx) {
         const lines = ["\n## Your Attention State"];
@@ -6799,11 +6834,17 @@ ${ctx.mergedContent.slice(0, SYSTEM_MAILBOX_MERGED_CHARS)}`);
             lines.push('- Give a generic acknowledgment like "Got it, will look into it" without substantive content');
             lines.push("- Ignore prior comments that provide important context for the current discussion");
             lines.push("");
-            lines.push("**Conversation termination \u2014 when NOT to reply:**");
-            lines.push('- The comment is just an acknowledgment ("Got it", "Will do", "Thanks", "Agreed") \u2014 do NOT reply');
-            lines.push("- Both parties have reached agreement or the discussion is resolved \u2014 do NOT reply");
-            lines.push('- Your reply would only be "Sounds good", "Agreed", or similar zero-information response \u2014 do NOT reply');
-            lines.push("- The comment does not ask a question, request action, or contain information you need to correct \u2014 do NOT reply");
+            lines.push("**MANDATORY outcome \u2014 you MUST end with exactly one of these:**");
+            lines.push("1. Call `task_comment` or `requirement_comment` tool to post your reply, OR");
+            lines.push("2. Output `[NO_REPLY_NEEDED]` in your text to explicitly signal that no response is warranted.");
+            lines.push("");
+            lines.push("If you finish without doing either of the above, the system will automatically retry your turn \u2014 your text output alone is NEVER sufficient.");
+            lines.push("");
+            lines.push("**When to use `[NO_REPLY_NEEDED]` \u2014 do NOT reply when:**");
+            lines.push('- The comment is just an acknowledgment ("Got it", "Will do", "Thanks", "Agreed")');
+            lines.push("- Both parties have reached agreement or the discussion is resolved");
+            lines.push('- Your reply would only be "Sounds good", "Agreed", or similar zero-information response');
+            lines.push("- The comment does not ask a question, request action, or contain information you need to correct");
             lines.push("- **Principle**: only comment when your reply adds **new information** or requests a **decision**. Avoid comment ping-pong.");
             break;
           case "review":
@@ -6917,8 +6958,7 @@ ${ctx.mergedContent.slice(0, SYSTEM_MAILBOX_MERGED_CHARS)}`);
             lines.push("6. **Hiring & Team Building** \u2014 Two phases: CREATE then INSTALL (only when user requests).");
             lines.push("   a) *Creating* (design the artifact): activate `agent-building` or `team-building` skill \u2192 write artifact files. Or `hub_search` to browse community packages.");
             lines.push("   b) *Installing* (deploy into org \u2014 ONLY when user explicitly asks to install/deploy/hire):");
-            lines.push("      - Quick hire from template: `team_list_templates` \u2192 `team_hire_agent`");
-            lines.push("      - Install artifact: `builder_install` (for custom-built or Hub-downloaded packages)");
+            lines.push("      - `package_list` \u2192 `package_install` (type: agent/team/skill)");
             lines.push("      - Hub one-step: `hub_install` (download + install)");
             lines.push("   c) After install: onboard via `agent_send_message` (project context) \u2192 `task_create` (initial work)");
             lines.push("   **IMPORTANT**: NEVER auto-install. Creating an artifact does NOT mean deploying it. Wait for explicit user request.");
@@ -7049,7 +7089,8 @@ ${ctx.mergedContent.slice(0, SYSTEM_MAILBOX_MERGED_CHARS)}`);
             totalUsed,
             available,
             usagePercent: Math.round(usagePercent * 10) / 10
-          }
+          },
+          systemCacheSegments: opts.systemCacheSegments
         };
       }
       /**
@@ -8213,7 +8254,7 @@ var init_tool_selector = __esm({
           "\u5206\u914D",
           "\u8DEF\u7531"
         ],
-        toolNames: ["team_list", "team_status", "delegate_message", "team_hire_agent", "team_list_templates"]
+        toolNames: ["team_list", "team_status", "delegate_message", "package_list", "package_install"]
       },
       {
         name: "deliverables",
@@ -8243,6 +8284,21 @@ var init_tool_selector = __esm({
           "\u7ECF\u9A8C"
         ],
         toolNames: ["deliverable_create", "deliverable_search", "deliverable_list", "deliverable_update"]
+      },
+      {
+        name: "builder",
+        keywords: [
+          "builder",
+          "artifact",
+          "deploy",
+          "skill",
+          "package",
+          "hub",
+          "\u90E8\u7F72",
+          "\u5DE5\u4EF6",
+          "\u6280\u80FD\u5305"
+        ],
+        toolNames: ["builder_install", "builder_list"]
       }
     ];
     BASE_TOOL_NAMES = /* @__PURE__ */ new Set([
@@ -41280,6 +41336,45 @@ async function searchBrave(query2, maxResults) {
     date: r.page_age
   }));
 }
+async function searchBing(query2, maxResults) {
+  const encoded = encodeURIComponent(query2);
+  let res;
+  try {
+    res = await proxyFetch(`https://www.bing.com/search?q=${encoded}`, {
+      headers: { "User-Agent": BING_UA }
+    });
+  } catch (err) {
+    throw new Error(`Network error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!res.ok)
+    throw new Error(`HTTP ${res.status} ${res.statusText}`);
+  const html = await res.text();
+  const results = parseBingHtml(html, maxResults);
+  if (results.length === 0)
+    throw new Error("Parsed 0 results from Bing");
+  return results;
+}
+function parseBingHtml(html, max) {
+  const results = [];
+  const algoRegex = /<li[^>]*class="b_algo"[^>]*>([\s\S]*?)<\/li>/g;
+  let match;
+  while ((match = algoRegex.exec(html)) !== null) {
+    if (results.length >= max)
+      break;
+    const item = match[1];
+    const linkMatch = item.match(/<a[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/i);
+    if (!linkMatch)
+      continue;
+    const url = linkMatch[1];
+    const title = stripHtml(linkMatch[2]);
+    if (!url || !title)
+      continue;
+    const snippetMatch = item.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+    const snippet = snippetMatch ? stripHtml(snippetMatch[1]) : "";
+    results.push({ title, url, snippet });
+  }
+  return results;
+}
 async function searchDuckDuckGo(query2, maxResults) {
   const encoded = encodeURIComponent(query2);
   let lastError;
@@ -41368,7 +41463,7 @@ function parseDDGHtml(html, maxResults) {
 function stripHtml(html) {
   return html.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
 }
-var SEARCH_TIMEOUT_MS, _dispatcher, WebSearchTool, DDG_UA, DDG_ENDPOINTS;
+var SEARCH_TIMEOUT_MS, _dispatcher, WebSearchTool, BING_UA, DDG_UA, DDG_ENDPOINTS;
 var init_web_search = __esm({
   "../core/dist/tools/web-search.js"() {
     "use strict";
@@ -41397,6 +41492,7 @@ var init_web_search = __esm({
         const backends = [
           { name: "Serper", fn: searchSerper },
           { name: "Brave", fn: searchBrave },
+          { name: "Bing", fn: searchBing },
           { name: "DuckDuckGo", fn: searchDuckDuckGo }
         ];
         const errors = [];
@@ -41428,6 +41524,7 @@ var init_web_search = __esm({
         });
       }
     };
+    BING_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
     DDG_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
     DDG_ENDPOINTS = [
       "https://lite.duckduckgo.com/lite/",
@@ -45500,6 +45597,7 @@ ${notification.stdoutTail}`);
               senderId,
               senderName: senderInfo?.name,
               senderRole: senderInfo?.role,
+              isFirstConversation: senderInfo?.isFirstConversation,
               responsePromise: { resolve: resolve20, reject }
             }
           });
@@ -45529,6 +45627,7 @@ ${notification.stdoutTail}`);
               senderId,
               senderName: senderInfo?.name,
               senderRole: senderInfo?.role,
+              isFirstConversation: senderInfo?.isFirstConversation,
               responsePromise: { resolve: resolve20, reject }
             }
           });
@@ -45675,7 +45774,7 @@ ${notification.stdoutTail}`);
           this.currentInteractingUserId = item.metadata.senderId;
         }
         const extra = item.payload.extra ?? {};
-        const senderInfo = item.metadata?.senderName ? { name: item.metadata.senderName, role: item.metadata.senderRole ?? "user" } : void 0;
+        const senderInfo = item.metadata?.senderName ? { name: item.metadata.senderName, role: item.metadata.senderRole ?? "user", isFirstConversation: item.metadata.isFirstConversation } : void 0;
         const resolveResponse = (reply) => {
           if (typeof item.metadata?.responsePromise?.resolve === "function") {
             item.metadata.responsePromise.resolve(stripCompletionMarker(reply));
@@ -46410,6 +46509,9 @@ ${conversationText}`
       setIdentityContext(ctx) {
         this.identityContext = ctx;
       }
+      getTeamName() {
+        return this.identityContext?.team?.name;
+      }
       addDynamicContextProvider(provider, key2) {
         const providerKey = key2 ?? `provider_${this.dynamicContextProviders.size}`;
         this.dynamicContextProviders.set(providerKey, provider);
@@ -46942,7 +47044,7 @@ ${block}
           await counter.ensureReady();
         }
         const cognitiveContext = await this.prepareCognitiveContext(scenario, effectiveMessage, senderId);
-        const systemPrompt = await this.contextEngine.buildSystemPrompt({
+        const { text: systemPrompt, segments: systemCacheSegments } = await this.contextEngine.buildSystemPrompt({
           agentId: this.id,
           agentName: this.config.name,
           role: this.role,
@@ -46985,7 +47087,8 @@ ${block}
           agentId: this.id,
           modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
           modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-          toolDefinitions: llmTools
+          toolDefinitions: llmTools,
+          systemCacheSegments
         });
         const messages = prepared.messages;
         log17.debug("Context usage for chat", { usagePercent: prepared.usage.usagePercent, totalUsed: prepared.usage.totalUsed });
@@ -46998,7 +47101,8 @@ ${block}
             messages,
             tools: llmTools.length > 0 ? llmTools : void 0,
             metadata: this.getLLMMetadata(sessionId),
-            compaction: useCompaction
+            compaction: useCompaction,
+            systemCacheSegments
           }, this.getEffectiveProvider()), "Chat LLM call");
           const tokensThisCall = response.usage.inputTokens + response.usage.outputTokens;
           this.updateTokensUsed(tokensThisCall);
@@ -47012,6 +47116,7 @@ ${block}
           });
           let toolIterations = 0;
           const effectiveMaxIter = options?.maxToolIterations ?? this._maxToolIterations;
+          const commentToolUsed = /* @__PURE__ */ new Set();
           while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
             if (++toolIterations > effectiveMaxIter) {
               log17.warn("Tool loop hit max iterations", {
@@ -47109,6 +47214,9 @@ ${block}
               for (let i = 0; i < response.toolCalls.length; i++) {
                 const tc = response.toolCalls[i];
                 this.loopDetector.record(tc.name, tc.arguments ?? {}, toolResults[i]?.content ?? "");
+                if (tc.name === "task_comment" || tc.name === "requirement_comment") {
+                  commentToolUsed.add(tc.name);
+                }
               }
               const loopCheck = this.loopDetector.check();
               if (loopCheck.detected) {
@@ -47158,7 +47266,8 @@ ${chatYield.item.payload.content}`;
               agentId: this.id,
               modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
               modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-              toolDefinitions: llmTools
+              toolDefinitions: llmTools,
+              systemCacheSegments
             });
             const updatedMessages = prepared2.messages;
             const llmStart2 = Date.now();
@@ -47166,7 +47275,8 @@ ${chatYield.item.payload.content}`;
               messages: updatedMessages,
               tools: llmTools.length > 0 ? llmTools : void 0,
               metadata: this.getLLMMetadata(sessionId),
-              compaction: useCompaction
+              compaction: useCompaction,
+              systemCacheSegments
             }, this.getEffectiveProvider()), "Chat LLM continuation");
             const tokens2 = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(tokens2);
@@ -47179,6 +47289,93 @@ ${chatYield.item.payload.content}`;
               success: true
             });
           }
+          const hasNoReplyMarker = /\[NO_REPLY_NEEDED\]/i.test(response.content ?? "");
+          if (scenario === "comment_response" && commentToolUsed.size === 0 && !hasNoReplyMarker && toolIterations < effectiveMaxIter) {
+            this.memory.appendMessage(sessionId, {
+              role: "assistant",
+              content: response.content,
+              toolCalls: response.toolCalls,
+              reasoningContent: response.reasoningContent
+            });
+            this.memory.appendMessage(sessionId, {
+              role: "user",
+              content: "[SYSTEM] You are about to end your turn WITHOUT posting a reply and WITHOUT marking [NO_REPLY_NEEDED]. In this scenario your text output is NOT visible to anyone. You MUST either: (1) call `task_comment` or `requirement_comment` tool to post your reply in the comment thread, OR (2) output exactly [NO_REPLY_NEEDED] if you have determined that no response is warranted. Do it now."
+            });
+            const reminderMessages = this.memory.getRecentMessages(sessionId, maxHistory);
+            const preparedReminder = await this.contextEngine.prepareMessages({
+              systemPrompt,
+              sessionMessages: reminderMessages,
+              memory: this.memory,
+              sessionId,
+              agentId: this.id,
+              modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
+              modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
+              toolDefinitions: llmTools,
+              systemCacheSegments
+            });
+            response = await this.withNetworkRetry(() => this.llmRouter.chat({
+              messages: preparedReminder.messages,
+              tools: llmTools.length > 0 ? llmTools : void 0,
+              metadata: this.getLLMMetadata(sessionId),
+              compaction: useCompaction,
+              systemCacheSegments
+            }, this.getEffectiveProvider()), "Chat LLM comment-reminder");
+            if (response.finishReason === "tool_use" && response.toolCalls?.length) {
+              const currentActId = this.state.currentActivity?.id;
+              this.memory.appendMessage(sessionId, {
+                role: "assistant",
+                content: response.content,
+                toolCalls: response.toolCalls,
+                reasoningContent: response.reasoningContent
+              });
+              const toolResults = await Promise.all(response.toolCalls.map(async (tc) => {
+                const toolStart = Date.now();
+                if (currentActId) {
+                  this.emitActivityLog(currentActId, "tool_start", tc.name, { arguments: tc.arguments });
+                }
+                try {
+                  let result = await this.executeTool(tc, void 0, sessionId);
+                  result = this.offloadLargeResult(tc.name, result);
+                  if (currentActId) {
+                    this.emitActivityLog(currentActId, "tool_end", tc.name, {
+                      durationMs: Date.now() - toolStart,
+                      success: !isErrorResult2(result),
+                      arguments: tc.arguments,
+                      result
+                    });
+                  }
+                  return { toolCallId: tc.id, content: result, error: false };
+                } catch (toolErr) {
+                  if (currentActId) {
+                    this.emitActivityLog(currentActId, "error", `Tool ${tc.name} failed: ${String(toolErr)}`);
+                  }
+                  return { toolCallId: tc.id, content: `Error: ${String(toolErr)}`, error: true };
+                }
+              }));
+              for (const tr of toolResults) {
+                this.memory.appendMessage(sessionId, { role: "tool", content: tr.content, toolCallId: tr.toolCallId });
+              }
+              const finalMessages = this.memory.getRecentMessages(sessionId, maxHistory);
+              const preparedFinal = await this.contextEngine.prepareMessages({
+                systemPrompt,
+                sessionMessages: finalMessages,
+                memory: this.memory,
+                sessionId,
+                agentId: this.id,
+                modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
+                modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
+                toolDefinitions: llmTools,
+                systemCacheSegments
+              });
+              response = await this.withNetworkRetry(() => this.llmRouter.chat({
+                messages: preparedFinal.messages,
+                tools: llmTools.length > 0 ? llmTools : void 0,
+                metadata: this.getLLMMetadata(sessionId),
+                compaction: useCompaction,
+                systemCacheSegments
+              }, this.getEffectiveProvider()), "Chat LLM comment-reminder-final");
+            }
+          }
           const rawReply = sanitizeLLMReply(response.content);
           const displayReply = stripCompletionMarker(rawReply);
           const outputCheck = await this.guardrails.checkOutput(displayReply, { agentId: this.id });
@@ -47264,7 +47461,7 @@ ${chatYield.item.payload.content}`;
         const userContent = await this.buildUserContent(userMessage, images, fileNames);
         this.memory.appendMessage(this.currentSessionId, { role: "user", content: userContent });
         const cognitiveContext = await this.prepareCognitiveContext("chat", effectiveMessage, senderId);
-        const systemPrompt = await this.contextEngine.buildSystemPrompt({
+        const { text: systemPrompt, segments: systemCacheSegments } = await this.contextEngine.buildSystemPrompt({
           agentId: this.id,
           agentName: this.config.name,
           role: this.role,
@@ -47300,7 +47497,8 @@ ${chatYield.item.payload.content}`;
           agentId: this.id,
           modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
           modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-          toolDefinitions: llmTools
+          toolDefinitions: llmTools,
+          systemCacheSegments
         });
         const messages = preparedStream.messages;
         log17.debug("Context usage for stream", { usagePercent: preparedStream.usage.usagePercent });
@@ -47336,7 +47534,7 @@ ${chatYield.item.payload.content}`;
         try {
           this.checkDailyTokenBudget();
           const llmStart = Date.now();
-          let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(this.currentSessionId), compaction: useCompaction }, wrappedOnEvent, this.getEffectiveProvider(), abortController.signal), "Stream LLM call", abortController.signal);
+          let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(this.currentSessionId), compaction: useCompaction, systemCacheSegments }, wrappedOnEvent, this.getEffectiveProvider(), abortController.signal), "Stream LLM call", abortController.signal);
           streamMarkerDelta.flush();
           const tokensThisCall = response.usage.inputTokens + response.usage.outputTokens;
           this.updateTokensUsed(tokensThisCall);
@@ -47494,7 +47692,8 @@ ${streamYield.item.payload.content}`;
               agentId: this.id,
               modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
               modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-              toolDefinitions: llmTools
+              toolDefinitions: llmTools,
+              systemCacheSegments
             });
             const updatedMessages = preparedCont.messages;
             if (cancelToken?.cancelled) {
@@ -47513,7 +47712,7 @@ ${streamYield.item.payload.content}`;
               return lastResponseContent || "";
             }
             const llmStart2 = Date.now();
-            response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages: updatedMessages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(this.currentSessionId), compaction: useCompaction }, wrappedOnEvent, this.getEffectiveProvider(), abortController.signal), "Stream LLM continuation", abortController.signal);
+            response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages: updatedMessages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(this.currentSessionId), compaction: useCompaction, systemCacheSegments }, wrappedOnEvent, this.getEffectiveProvider(), abortController.signal), "Stream LLM continuation", abortController.signal);
             streamMarkerDelta.flush();
             const tokens2 = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(tokens2);
@@ -47751,7 +47950,7 @@ ${streamYield.item.payload.content}`;
           this.memory.appendMessage(sessionId, { role: "user", content: taskPrompt });
         }
         const cognitiveContext = await this.prepareCognitiveContext("task_execution", taskPrompt);
-        const systemPrompt = await this.contextEngine.buildSystemPrompt({
+        const { text: systemPrompt, segments: systemCacheSegments } = await this.contextEngine.buildSystemPrompt({
           agentId: this.id,
           agentName: this.config.name,
           role: this.role,
@@ -47818,12 +48017,13 @@ ${streamYield.item.payload.content}`;
             agentId: this.id,
             modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
             modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-            toolDefinitions: llmTools
+            toolDefinitions: llmTools,
+            systemCacheSegments
           });
           const messages = preparedTask.messages;
           log17.debug("Context usage for task execution", { taskId: taskId2, usagePercent: preparedTask.usage.usagePercent, totalUsed: preparedTask.usage.totalUsed });
           let taskLlmStart = Date.now();
-          let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction }, handleStreamEvent, this.getEffectiveProvider(), abortController.signal), "Task execution LLM call", abortController.signal);
+          let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction, systemCacheSegments }, handleStreamEvent, this.getEffectiveProvider(), abortController.signal), "Task execution LLM call", abortController.signal);
           let taskLlmTokens = response.usage.inputTokens + response.usage.outputTokens;
           this.updateTokensUsed(taskLlmTokens);
           this.calibrateTokenCounter(response.usage.inputTokens);
@@ -48005,14 +48205,16 @@ ${yieldResult.item.payload.content}`
               agentId: this.id,
               modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
               modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-              toolDefinitions: llmTools
+              toolDefinitions: llmTools,
+              systemCacheSegments
             });
             taskLlmStart = Date.now();
             response = await this.withNetworkRetry(() => this.llmRouter.chatStream({
               messages: preparedTaskCont.messages,
               tools: llmTools.length > 0 ? llmTools : void 0,
               metadata: this.getLLMMetadata(sessionId),
-              compaction: useCompaction
+              compaction: useCompaction,
+              systemCacheSegments
             }, handleStreamEvent, this.getEffectiveProvider(), abortController.signal), "Task execution LLM continuation", abortController.signal);
             taskLlmTokens = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(taskLlmTokens);
@@ -48054,14 +48256,16 @@ ${yieldResult.item.payload.content}`
               agentId: this.id,
               modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
               modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-              toolDefinitions: llmTools
+              toolDefinitions: llmTools,
+              systemCacheSegments
             });
             taskLlmStart = Date.now();
             response = await this.withNetworkRetry(() => this.llmRouter.chatStream({
               messages: preparedFinal.messages,
               tools: llmTools.length > 0 ? llmTools : void 0,
               metadata: this.getLLMMetadata(sessionId),
-              compaction: useCompaction
+              compaction: useCompaction,
+              systemCacheSegments
             }, handleStreamEvent, this.getEffectiveProvider(), abortController.signal), "Task execution final submit reminder", abortController.signal);
             taskLlmTokens = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(taskLlmTokens);
@@ -48185,7 +48389,7 @@ ${yieldResult.item.payload.content}`
         this.memory.getOrCreateSession(this.id, sessionId);
         this.memory.appendMessage(sessionId, { role: "user", content: userMessage });
         const cognitiveContext = await this.prepareCognitiveContext("chat", userMessage);
-        const systemPrompt = await this.contextEngine.buildSystemPrompt({
+        const { text: systemPrompt, segments: systemCacheSegments } = await this.contextEngine.buildSystemPrompt({
           agentId: this.id,
           agentName: this.config.name,
           role: this.role,
@@ -48246,11 +48450,12 @@ ${yieldResult.item.payload.content}`
             agentId: this.id,
             modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
             modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-            toolDefinitions: llmTools
+            toolDefinitions: llmTools,
+            systemCacheSegments
           });
           const messages = prepared.messages;
           let risLlmStart = Date.now();
-          let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction }, handleStreamEvent, this.getEffectiveProvider()), "RespondInSession LLM call");
+          let response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction, systemCacheSegments }, handleStreamEvent, this.getEffectiveProvider()), "RespondInSession LLM call");
           let risTokens = response.usage.inputTokens + response.usage.outputTokens;
           this.updateTokensUsed(risTokens);
           this.calibrateTokenCounter(response.usage.inputTokens);
@@ -48308,10 +48513,11 @@ ${yieldResult.item.payload.content}`
               agentId: this.id,
               modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
               modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
-              toolDefinitions: llmTools
+              toolDefinitions: llmTools,
+              systemCacheSegments
             });
             risLlmStart = Date.now();
-            response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages: preparedCont.messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction }, handleStreamEvent, this.getEffectiveProvider()), "RespondInSession LLM continuation");
+            response = await this.withNetworkRetry(() => this.llmRouter.chatStream({ messages: preparedCont.messages, tools: llmTools.length > 0 ? llmTools : void 0, metadata: this.getLLMMetadata(sessionId), compaction: useCompaction, systemCacheSegments }, handleStreamEvent, this.getEffectiveProvider()), "RespondInSession LLM continuation");
             risTokens = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(risTokens);
             this.calibrateTokenCounter(response.usage.inputTokens);
@@ -48860,6 +49066,19 @@ ${escalationReason}`;
       }
       async handleHeartbeat(ctx) {
         log17.info("Processing heartbeat check-in");
+        const queuedNonHeartbeat = this.mailbox.getQueuedItems().filter((i) => i.sourceType !== "heartbeat" && i.status === "queued").length;
+        const fingerprint = `q:${queuedNonHeartbeat}`;
+        if (fingerprint === this.lastHeartbeatFingerprint && queuedNonHeartbeat === 0) {
+          this.consecutiveIdleHeartbeats++;
+          log17.info("Heartbeat: no changes detected, skipping LLM call", {
+            consecutiveIdle: this.consecutiveIdleHeartbeats
+          });
+          this.state.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+          this.metricsCollector.recordHeartbeat(true);
+          return;
+        }
+        this.lastHeartbeatFingerprint = fingerprint;
+        this.consecutiveIdleHeartbeats = 0;
         const activityId = this.startActivity("heartbeat", "Heartbeat check-in", {});
         let lastHeartbeatSummary = "";
         try {
@@ -48958,8 +49177,8 @@ ${todayLog.slice(0, HEARTBEAT_DAILY_LOG_CHARS)}
           "- Common sections: `procedures`, `conventions`, `preferences`, `domain-knowledge`.",
           "",
           "**Shareable skills** (for team-wide practices):",
-          '- Check existing skills first: `discover_tools({ mode: "list_skills" })` and `builder_list`.',
-          "- To update an existing skill: edit files in `~/.markus/builder-artifacts/skills/{name}/`, bump version, re-install with `builder_install`.",
+          '- Check existing skills first: `discover_tools({ mode: "list_skills" })` and `package_list`.',
+          "- To update an existing skill: edit files in `~/.markus/builder-artifacts/skills/{name}/`, bump version, re-install with `package_install`.",
           "",
           "**Direct self-evolution** (simplest and most impactful):",
           "- **Update ROLE.md** \u2014 When you discover a behavioral rule, working style, or guiding principle that should always apply, append it to your ROLE.md via `file_edit`. ROLE.md is loaded into every conversation, so changes take effect immediately. Read first, then append. No need to accumulate 3 insights \u2014 even a single validated lesson can warrant a role update if it is fundamental.",
@@ -48971,7 +49190,7 @@ ${todayLog.slice(0, HEARTBEAT_DAILY_LOG_CHARS)}
           '| Single insight / gotcha | `memory_save` with tags: `["insight"]` |',
           '| Tool tip or preference | `memory_save` with tags: `["insight", "tool:<name>"]` |',
           '| Multi-step repeatable workflow | `memory_update_longterm({ section: "procedures", mode: "patch" })` |',
-          "| Practice worth sharing with the team | Create skill via **skill-building**, then install with `builder_install` |",
+          "| Practice worth sharing with the team | Create skill via **skill-building**, then install with `package_install` |",
           "| Behavioral rule or guiding principle | Update ROLE.md (`file_read` \u2192 `file_edit` to append) |",
           "| New recurring check for your patrol | Update HEARTBEAT.md (`file_read` \u2192 `file_edit`) |",
           "",
@@ -49077,10 +49296,12 @@ ${todayLog.slice(0, HEARTBEAT_DAILY_LOG_CHARS)}
           "discover_tools",
           "notify_user",
           "request_user_approval",
-          "recall_activity"
+          "recall_activity",
+          "builder_install",
+          "builder_list"
         ];
         if (isManager) {
-          baseTools.push("task_board_health", "task_cleanup_duplicates", "task_assign", "team_status", "deliverable_create", "deliverable_search", "team_hire_agent", "team_list_templates", "builder_install", "builder_list");
+          baseTools.push("task_board_health", "task_cleanup_duplicates", "task_assign", "team_status", "deliverable_create", "deliverable_search", "package_install", "package_list");
         }
         const HEARTBEAT_ALLOWED_TOOLS = new Set(baseTools);
         const HEARTBEAT_MAX_RETRIES = 3;
@@ -49177,12 +49398,15 @@ ${todayLog.slice(0, HEARTBEAT_DAILY_LOG_CHARS)}
        * 2. Memory dream: prune, deduplicate, merge (once per day)
        */
       lastDreamDate = "";
+      lastHeartbeatFingerprint = "";
+      consecutiveIdleHeartbeats = 0;
       async consolidateMemory() {
         try {
           const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
           const entries2 = this.memory.getEntries();
-          if (entries2.length >= 50 && this.lastDreamDate !== today) {
-            this.lastDreamDate = today;
+          const dreamKey = entries2.length > 500 ? `${today}_${Math.floor(Date.now() / (6 * 36e5))}` : today;
+          if (entries2.length >= 50 && this.lastDreamDate !== dreamKey) {
+            this.lastDreamDate = dreamKey;
             await this.dreamConsolidateMemory(entries2);
             this.pruneMemoryMd();
           }
@@ -49196,7 +49420,7 @@ ${todayLog.slice(0, HEARTBEAT_DAILY_LOG_CHARS)}
        * outdated items, and merge opportunities. Apply changes programmatically.
        */
       async dreamConsolidateMemory(entries2) {
-        const MAX_ENTRIES_FOR_LLM = 200;
+        const MAX_ENTRIES_FOR_LLM = 500;
         const truncated = entries2.length > MAX_ENTRIES_FOR_LLM;
         const batch = truncated ? entries2.slice(-MAX_ENTRIES_FOR_LLM) : entries2;
         const entryList = batch.map((e, i) => {
@@ -49267,8 +49491,8 @@ ${knowledgePreview}
             return;
           }
           const rawPlan = JSON.parse(jsonMatch[0]);
-          const MAX_REMOVE_PER_CYCLE = 10;
-          const MAX_MERGE_PER_CYCLE = 5;
+          const MAX_REMOVE_PER_CYCLE = 50;
+          const MAX_MERGE_PER_CYCLE = 20;
           const entryIds = new Set(batch.map((e) => e.id));
           const plan = {
             remove: (rawPlan.remove ?? []).filter((id) => entryIds.has(id)).slice(0, MAX_REMOVE_PER_CYCLE),
@@ -49389,6 +49613,52 @@ ${promo.content}` : promo.content;
           if (!inDailyReport)
             afterSectionPrune.push(line);
         }
+        const sections = [];
+        let currentHeading = "";
+        let currentBody = [];
+        let sectionStart = 0;
+        for (let i = 0; i <= afterSectionPrune.length; i++) {
+          const line = i < afterSectionPrune.length ? afterSectionPrune[i] : void 0;
+          const isHeading = line !== void 0 && /^#{1,3}\s/.test(line);
+          if (isHeading || line === void 0) {
+            if (currentHeading || currentBody.length > 0) {
+              sections.push({
+                heading: currentHeading,
+                body: currentBody.join("\n").trim(),
+                startIdx: sectionStart
+              });
+            }
+            currentHeading = line ?? "";
+            currentBody = [];
+            sectionStart = i;
+          } else {
+            currentBody.push(line);
+          }
+        }
+        const headingLastIdx = /* @__PURE__ */ new Map();
+        const normalizeHeading = (h) => h.replace(/^#+\s*/, "").trim().toLowerCase();
+        for (let i = 0; i < sections.length; i++) {
+          const key2 = normalizeHeading(sections[i].heading);
+          if (key2)
+            headingLastIdx.set(key2, i);
+        }
+        const deduped = [];
+        for (let i = 0; i < sections.length; i++) {
+          const s = sections[i];
+          const key2 = normalizeHeading(s.heading);
+          if (key2 && headingLastIdx.get(key2) !== i && headingLastIdx.has(key2)) {
+            continue;
+          }
+          deduped.push(s);
+        }
+        afterSectionPrune.length = 0;
+        for (const s of deduped) {
+          if (s.heading)
+            afterSectionPrune.push(s.heading);
+          if (s.body)
+            afterSectionPrune.push(s.body);
+          afterSectionPrune.push("");
+        }
         const outputLines = [];
         let inThinkBlock = false;
         for (const line of afterSectionPrune) {
@@ -50181,6 +50451,73 @@ var init_browser_session = __esm({
 });
 
 // ../core/dist/tools/manager.js
+function createBuilderTools(ctx) {
+  return [
+    ...ctx.listArtifacts ? [
+      {
+        name: "builder_list",
+        description: "List builder artifacts (custom-created or Hub-downloaded agent/team/skill packages). These can be installed with builder_install.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["agent", "team", "skill"],
+              description: "Filter by artifact type (optional)"
+            }
+          }
+        },
+        async execute(args) {
+          try {
+            const artifacts = ctx.listArtifacts(args["type"]);
+            return JSON.stringify({ artifacts, count: artifacts.length });
+          } catch (error) {
+            return JSON.stringify({ status: "error", error: String(error) });
+          }
+        }
+      }
+    ] : [],
+    ...ctx.installArtifact ? [
+      {
+        name: "builder_install",
+        description: "Install a builder artifact \u2014 deploys an agent, team, or skill package into the live organization. For agents/teams: after installation, onboard with project context and assign initial tasks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["agent", "team", "skill"],
+              description: "Artifact type"
+            },
+            name: { type: "string", description: "Artifact name (from builder_list)" }
+          },
+          required: ["type", "name"]
+        },
+        async execute(args) {
+          try {
+            const type = args["type"]?.trim();
+            const name = args["name"]?.trim();
+            if (!type || !["agent", "team", "skill"].includes(type))
+              return JSON.stringify({ status: "error", error: "type is required and must be one of: agent, team, skill" });
+            if (!name)
+              return JSON.stringify({ status: "error", error: "name is required \u2014 provide the artifact name from builder_list" });
+            const result = await ctx.installArtifact(type, name);
+            const isAgentOrTeam = result.type === "agent" || result.type === "team";
+            return JSON.stringify({
+              status: "success",
+              ...result,
+              ...isAgentOrTeam ? {
+                next_steps: "Installed successfully. Next: onboard new agent(s) with project context via agent_send_message, then assign initial tasks via task_create."
+              } : {}
+            });
+          } catch (error) {
+            return JSON.stringify({ status: "error", error: String(error) });
+          }
+        }
+      }
+    ] : []
+  ];
+}
 function createManagerTools(ctx) {
   return [
     {
@@ -50299,79 +50636,34 @@ function createManagerTools(ctx) {
         }
       }
     ] : [],
-    ...ctx.listTemplates ? [
-      {
-        name: "team_list_templates",
-        description: "List available agent templates that can be hired. Each template has a role, description, and category.",
-        inputSchema: {
-          type: "object",
-          properties: {}
-        },
-        async execute() {
-          try {
-            const templates = ctx.listTemplates();
-            return JSON.stringify({ templates, count: templates.length });
-          } catch (error) {
-            return JSON.stringify({ status: "error", error: String(error) });
-          }
-        }
-      }
-    ] : [],
-    ...ctx.hireFromTemplate ? [
-      {
-        name: "team_hire_agent",
-        description: "Hire a new agent from a template and add them to your team. After hiring, onboard the agent: send a welcome message with project context via agent_send_message, then assign initial tasks via task_create.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            template_id: { type: "string", description: "Template ID (from team_list_templates)" },
-            name: { type: "string", description: "Display name for the new agent" },
-            skills: {
-              type: "array",
-              items: { type: "string" },
-              description: "Optional skill IDs to assign"
-            }
-          },
-          required: ["template_id", "name"]
-        },
-        async execute(args) {
-          try {
-            const templateId = args["template_id"]?.trim();
-            const name = args["name"]?.trim();
-            if (!templateId)
-              return JSON.stringify({ status: "error", error: "template_id is required" });
-            if (!name)
-              return JSON.stringify({ status: "error", error: "name is required \u2014 please provide a display name for the new agent" });
-            const result = await ctx.hireFromTemplate(templateId, name, args["skills"]);
-            return JSON.stringify({
-              status: "success",
-              agent: result,
-              next_steps: "Agent created and started. Next: onboard them with project context via agent_send_message, then assign initial tasks via task_create."
-            });
-          } catch (error) {
-            return JSON.stringify({ status: "error", error: String(error) });
-          }
-        }
-      }
-    ] : [],
     ...ctx.listArtifacts ? [
       {
-        name: "builder_list",
-        description: "List builder artifacts (custom-created or Hub-downloaded agent/team/skill packages). These can be installed with builder_install.",
+        name: "package_list",
+        description: 'List all available packages. type "agent": built-in roles (developer, content-writer, etc.) and custom agent packages. type "team": team templates (content-team, research-lab, etc.). type "skill": skill packages. Omit type to list all. Install with package_install. To find more online, use hub_search.',
         inputSchema: {
           type: "object",
           properties: {
             type: {
               type: "string",
               enum: ["agent", "team", "skill"],
-              description: "Filter by artifact type (optional)"
+              description: "Filter by type (optional). Omit to list all."
             }
           }
         },
         async execute(args) {
           try {
-            const artifacts = ctx.listArtifacts(args["type"]);
-            return JSON.stringify({ artifacts, count: artifacts.length });
+            const type = args["type"];
+            const artifacts = ctx.listArtifacts(type);
+            const roles = (!type || type === "agent") && ctx.listTemplates ? ctx.listTemplates() : [];
+            const roleItems = roles.map((r) => ({
+              type: "agent",
+              source: "role",
+              name: r.id ?? r.name,
+              description: r.description ?? r.name,
+              ...r
+            }));
+            const items = [...roleItems, ...artifacts];
+            return JSON.stringify({ items, count: items.length });
           } catch (error) {
             return JSON.stringify({ status: "error", error: String(error) });
           }
@@ -50443,17 +50735,23 @@ function createManagerTools(ctx) {
     ] : [],
     ...ctx.installArtifact ? [
       {
-        name: "builder_install",
-        description: "Install a builder artifact \u2014 deploys an agent, team, or skill package into the live organization. For agents/teams: after installation, onboard with project context and assign initial tasks.",
+        name: "package_install",
+        description: 'Install a package into the live organization. type "agent": hire/install an agent (from a built-in role or a custom package). type "team": deploy a full team with all members, norms, and starter tasks. type "skill": install a skill package. Use package_list to see what is available.',
         inputSchema: {
           type: "object",
           properties: {
             type: {
               type: "string",
               enum: ["agent", "team", "skill"],
-              description: "Artifact type"
+              description: "Package type"
             },
-            name: { type: "string", description: "Artifact name (from builder_list)" }
+            name: { type: "string", description: "Package name (from package_list)" },
+            agent_name: { type: "string", description: 'Display name for the new agent (required when installing from a built-in role, e.g. "developer")' },
+            skills: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional skill IDs to assign to the new agent"
+            }
           },
           required: ["type", "name"]
         },
@@ -50464,13 +50762,36 @@ function createManagerTools(ctx) {
             if (!type || !["agent", "team", "skill"].includes(type))
               return JSON.stringify({ status: "error", error: "type is required and must be one of: agent, team, skill" });
             if (!name)
-              return JSON.stringify({ status: "error", error: "name is required \u2014 provide the artifact name from builder_list" });
+              return JSON.stringify({ status: "error", error: "name is required \u2014 use package_list to see available packages" });
+            if (type === "agent") {
+              try {
+                const result2 = await ctx.installArtifact(type, name);
+                return JSON.stringify({
+                  status: "success",
+                  ...result2,
+                  next_steps: "Installed successfully. Next: onboard new agent with project context via agent_send_message, then assign tasks via task_create."
+                });
+              } catch {
+                if (ctx.hireFromTemplate) {
+                  const agentName = args["agent_name"]?.trim();
+                  if (!agentName)
+                    return JSON.stringify({ status: "error", error: "agent_name is required when installing from a built-in role \u2014 provide a display name for the new agent" });
+                  const result2 = await ctx.hireFromTemplate(name, agentName, args["skills"]);
+                  return JSON.stringify({
+                    status: "success",
+                    type: "agent",
+                    agent: result2,
+                    next_steps: "Agent hired and started. Next: onboard with project context via agent_send_message, then assign tasks via task_create."
+                  });
+                }
+                throw new Error(`Agent package not found: ${name}. Use package_list to see available packages.`);
+              }
+            }
             const result = await ctx.installArtifact(type, name);
-            const isAgentOrTeam = result.type === "agent" || result.type === "team";
             return JSON.stringify({
               status: "success",
               ...result,
-              ...isAgentOrTeam ? {
+              ...type === "team" ? {
                 next_steps: "Installed successfully. Next: onboard new agent(s) with project context via agent_send_message, then assign initial tasks via task_create."
               } : {}
             });
@@ -50615,14 +50936,40 @@ function createA2ATools(ctx) {
     },
     {
       name: "agent_list_colleagues",
-      description: "List all other agents in your organization that you can collaborate with. Shows their names, roles, skills, and current status.",
+      description: "List all other agents in your organization grouped by team. Shows team structure, roles, skills, and current status.",
       inputSchema: {
         type: "object",
         properties: {}
       },
       async execute() {
         const colleagues = ctx.listColleagues().filter((a) => a.id !== ctx.selfId);
-        return JSON.stringify({ colleagues, count: colleagues.length });
+        const byTeam = /* @__PURE__ */ new Map();
+        for (const c of colleagues) {
+          const key2 = c.teamId ?? "__ungrouped__";
+          if (!byTeam.has(key2))
+            byTeam.set(key2, []);
+          byTeam.get(key2).push(c);
+        }
+        const lines = [];
+        lines.push(`Organization colleagues: ${colleagues.length} agents
+`);
+        for (const [teamId, members] of byTeam) {
+          const manager = members.find((m) => m.agentRole === "manager");
+          const teamLabel = members[0]?.teamName ?? teamId;
+          if (teamId === "__ungrouped__") {
+            lines.push(`\u2500\u2500 Ungrouped \u2500\u2500`);
+          } else {
+            lines.push(`\u2500\u2500 Team: ${teamLabel}${manager ? ` (manager: ${manager.name})` : ""} \u2500\u2500`);
+          }
+          const sorted = [...members].sort((a, b) => a.agentRole === "manager" ? -1 : b.agentRole === "manager" ? 1 : 0);
+          for (const m of sorted) {
+            const badge = m.agentRole === "manager" ? " [Manager]" : "";
+            const skills = m.skills?.length ? ` | skills: ${m.skills.join(", ")}` : "";
+            lines.push(`  \u2022 ${m.name} (${m.id})${badge} \u2014 ${m.role} | ${m.status}${skills}`);
+          }
+          lines.push("");
+        }
+        return lines.join("\n");
       }
     },
     ...ctx.sendGroupMessage ? [{
@@ -50710,7 +51057,7 @@ function createA2ATools(ctx) {
             type: "string",
             description: 'Required when scope="channel". The channel key (e.g., "group:<teamId>" for team chats, "dm:<id1>_<id2>" for DMs).'
           },
-          limit: { type: "number", description: "Number of items to fetch (default 30, max 50)." },
+          limit: { type: "number", description: "Number of items to fetch (default 80, max 200)." },
           before: { type: "string", description: "ISO timestamp \u2014 fetch items older than this for pagination. Omit for most recent." }
         },
         required: ["scope"]
@@ -50722,11 +51069,11 @@ function createA2ATools(ctx) {
           if (!channelKey) {
             return JSON.stringify({ status: "error", error: 'channel_key is required when scope="channel"' });
           }
-          const limit = Math.min(args["limit"] ?? 30, 50);
+          const limit = Math.min(args["limit"] ?? 80, 200);
           const before2 = args["before"];
           try {
             const result = await ctx.getChannelMessages(channelKey, limit, before2);
-            const formatted = result.messages.map((m) => `[${m.createdAt}] ${m.senderType === "agent" ? `[agent] ${m.senderName}` : `[human] ${m.senderName}`}: ${m.text.slice(0, 500)}`);
+            const formatted = result.messages.map((m) => `[${m.createdAt}] ${m.senderType === "agent" ? `[agent] ${m.senderName}` : `[human] ${m.senderName}`}: ${m.text.slice(0, 2e3)}`);
             return JSON.stringify({
               messages: formatted,
               count: result.messages.length,
@@ -51182,6 +51529,15 @@ function createAgentTaskTools(ctx) {
             items: { type: "string" },
             description: "Update the list of task IDs that block this task. Only the task creator can modify this field. Pass an empty array to clear all blockers."
           },
+          reviewer_id: {
+            type: "string",
+            description: "New reviewer agent or human ID. Only the task creator or a manager can change the reviewer."
+          },
+          reviewer_type: {
+            type: "string",
+            enum: ["agent", "human"],
+            description: "Whether the new reviewer is an agent or a human user. Required when changing reviewer_id."
+          },
           schedule: {
             type: "object",
             description: 'Update the schedule for a scheduled (recurring) task. Only works on tasks with taskType "scheduled". Set either "every" OR "cron", not both.',
@@ -51202,20 +51558,30 @@ function createAgentTaskTools(ctx) {
           const note = args["note"];
           const description = args["description"];
           const blockedBy = args["blocked_by"];
-          if (blockedBy !== void 0) {
+          const reviewerId = args["reviewer_id"];
+          const reviewerType = args["reviewer_type"];
+          if (blockedBy !== void 0 || reviewerId !== void 0) {
             const existing = ctx.getTask ? await ctx.getTask(taskId2) : null;
             const createdBy = existing?.["createdBy"];
-            if (createdBy && createdBy !== ctx.agentId) {
+            if (blockedBy !== void 0 && createdBy && createdBy !== ctx.agentId) {
               return JSON.stringify({
                 status: "denied",
                 error: "Only the task creator can modify blocked_by. You are not the creator of this task."
               });
             }
+            if (reviewerId !== void 0 && createdBy && createdBy !== ctx.agentId) {
+              return JSON.stringify({
+                status: "denied",
+                error: "Only the task creator or a manager can change the reviewer."
+              });
+            }
           }
-          if ((description !== void 0 || blockedBy !== void 0) && ctx.updateTaskFields) {
+          if ((description !== void 0 || blockedBy !== void 0 || reviewerId !== void 0) && ctx.updateTaskFields) {
             await ctx.updateTaskFields(taskId2, {
               ...description !== void 0 ? { description } : {},
-              ...blockedBy !== void 0 ? { blockedBy } : {}
+              ...blockedBy !== void 0 ? { blockedBy } : {},
+              ...reviewerId !== void 0 ? { reviewerId } : {},
+              ...reviewerType !== void 0 ? { reviewerType } : {}
             });
           }
           const schedule = args["schedule"];
@@ -51404,7 +51770,7 @@ function createAgentTaskTools(ctx) {
     ...ctx.addTaskNote ? [
       {
         name: "task_note",
-        description: "Add a progress note or comment to a task without changing its status. Use this to log intermediate findings, decisions, or observations while working on a task.",
+        description: "Add a one-way progress note to a task's timeline log without changing its status. Use this to record intermediate findings, decisions, or milestones. For interactive discussion with other agents or humans, use task_comment instead.",
         inputSchema: {
           type: "object",
           properties: {
@@ -52642,6 +53008,48 @@ ${content}` : content;
         log24.info("Agent updated long-term memory", { agentId: ctx.agentId, section: section4, mode, contentLen: content.length });
         return JSON.stringify({ status: "updated", section: section4, mode });
       }
+    },
+    {
+      name: "memory_delete",
+      description: "Delete specific entries from your memory buffer (memories.json). Use this to clean up outdated, incorrect, or redundant observations. Provide either a list of entry IDs (from memory_list/memory_search) or a tag to remove all entries with that tag. Maximum 20 entries per call.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of memory entry IDs to delete. Use memory_list or memory_search to find IDs."
+          },
+          tag: {
+            type: "string",
+            description: "Delete all entries with this tag. Alternative to specifying individual IDs."
+          }
+        }
+      },
+      async execute(args) {
+        const ids = args["ids"];
+        const tag = args["tag"];
+        if (!ids?.length && !tag) {
+          return JSON.stringify({ status: "error", error: "Provide either ids or tag to delete." });
+        }
+        const MAX_DELETE = 20;
+        let removed = 0;
+        if (ids?.length) {
+          const capped = ids.slice(0, MAX_DELETE);
+          removed = ctx.memory.removeEntries(capped);
+          if (ctx.semanticSearch?.isEnabled()) {
+            for (const id of capped) {
+              ctx.semanticSearch.deleteMemory(id).catch((err) => {
+                log24.warn("Failed to remove memory from semantic index", { error: String(err) });
+              });
+            }
+          }
+        } else if (tag) {
+          removed = ctx.memory.removeEntriesByTag(tag);
+        }
+        log24.info("Agent deleted memories", { agentId: ctx.agentId, removed, byTag: tag ?? null });
+        return JSON.stringify({ status: "deleted", removed });
+      }
     }
   ];
 }
@@ -54354,6 +54762,14 @@ Known issues: ${knownIssues}` : ""}`
               agent.registerTool(tool);
           }
         }
+        if (this.builderService) {
+          const builderTools = createBuilderTools({
+            installArtifact: (type, name) => this.builderService.installArtifact(type, name),
+            listArtifacts: (type) => this.builderService.listArtifacts(type)
+          });
+          for (const tool of builderTools)
+            agent.registerTool(tool);
+        }
         const mcpConfigs = request.mcpServers ?? this.globalMcpServers;
         if (mcpConfigs) {
           for (const [serverName, serverConfig] of Object.entries(mcpConfigs)) {
@@ -54915,6 +55331,14 @@ Known issues: ${knownIssues}` : ""}`
               agent.registerTool(tool);
           }
         }
+        if (this.builderService) {
+          const builderTools = createBuilderTools({
+            installArtifact: (type, name) => this.builderService.installArtifact(type, name),
+            listArtifacts: (type) => this.builderService.listArtifacts(type)
+          });
+          for (const tool of builderTools)
+            agent.registerTool(tool);
+        }
         if (this.agentAuditCallback) {
           const cb = this.agentAuditCallback;
           agent.setAuditCallback((event) => cb(id, event));
@@ -55141,6 +55565,7 @@ Known issues: ${knownIssues}` : ""}`
             skills: a.config.skills,
             activeTaskCount: state.activeTaskCount ?? 0,
             teamId: a.config.teamId,
+            teamName: a.getTeamName(),
             lastError: state.lastError,
             lastErrorAt: state.lastErrorAt,
             currentTaskId: state.currentTaskId,
@@ -55562,8 +55987,9 @@ var init_anthropic = __esm({
           max_tokens: request.maxTokens ?? this.maxTokens,
           messages
         };
-        if (systemMsg)
-          body["system"] = getTextContent(systemMsg.content);
+        if (systemMsg) {
+          body["system"] = this.buildSystemContent(getTextContent(systemMsg.content), request.systemCacheSegments);
+        }
         if (request.temperature !== void 0)
           body["temperature"] = request.temperature;
         if (request.stopSequences?.length)
@@ -55603,8 +56029,9 @@ var init_anthropic = __esm({
           messages,
           stream: true
         };
-        if (systemMsg)
-          body["system"] = getTextContent(systemMsg.content);
+        if (systemMsg) {
+          body["system"] = this.buildSystemContent(getTextContent(systemMsg.content), request.systemCacheSegments);
+        }
         if (request.temperature !== void 0)
           body["temperature"] = request.temperature;
         if (request.stopSequences?.length)
@@ -55789,6 +56216,21 @@ var init_anthropic = __esm({
       isCompactionSupported() {
         return this.model.startsWith("claude-opus-4") || this.model.startsWith("claude-sonnet-4");
       }
+      /**
+       * Build the `system` field for the Anthropic API. When structured cache
+       * segments are provided, returns an array of content blocks with
+       * `cache_control` breakpoints so the API can cache stable prefixes.
+       * Falls back to a plain string when no segments are available.
+       */
+      buildSystemContent(plainText, segments) {
+        if (!segments || segments.length <= 1)
+          return plainText;
+        return segments.filter((s) => s.content.length > 0).map((s) => ({
+          type: "text",
+          text: s.content,
+          ...s.cacheBreakpoint ? { cache_control: { type: "ephemeral" } } : {}
+        }));
+      }
       convertResponse(data) {
         let content = "";
         let compactionContent;
@@ -57114,6 +57556,13 @@ var init_oauth_manager = __esm({
 });
 
 // ../core/dist/llm/router.js
+function maskApiKey(key2) {
+  if (!key2)
+    return void 0;
+  if (key2.length <= 8)
+    return "****";
+  return key2.slice(0, 4) + "..." + key2.slice(-4);
+}
 function buildTiers(providerNames, defaultProvider) {
   const tiers = [];
   if (providerNames.includes(defaultProvider)) {
@@ -57792,6 +58241,8 @@ var init_router = __esm({
           const builtinModels = BUILTIN_MODEL_CATALOG.filter((m) => m.provider === name);
           const customCatalogModels = this.customModelCatalog.get(name) ?? [];
           const mergedModels = [...builtinModels, ...customCatalogModels.filter((cm) => !builtinModels.some((bm) => bm.id === cm.id))];
+          const rawKey = p.apiKey ?? "";
+          const keySource = oauthProfile?.authType === "oauth" ? "oauth" : rawKey ? "config" : void 0;
           providers[name] = {
             name,
             displayName: PROVIDER_DISPLAY_NAMES[name] ?? name,
@@ -57799,6 +58250,8 @@ var init_router = __esm({
             baseUrl: p.baseUrl,
             configured: true,
             enabled: this.isProviderEnabled(name),
+            apiKeyPreview: maskApiKey(rawKey),
+            apiKeySource: keySource,
             contextWindow: customModels?.contextWindow ?? modelDef?.contextWindow,
             maxOutputTokens: customModels?.maxOutputTokens ?? modelDef?.maxOutputTokens,
             cost: customModels?.cost ?? modelDef?.cost,
@@ -59874,11 +60327,13 @@ function loadTeamTemplateFromDir(dirPath) {
         name: m.name,
         count: m.count,
         role: m.role,
+        description: m.description,
         skills: m.skills ?? []
       })),
       tags: manifest.tags ?? [],
       category: manifest.category,
       icon: manifest.icon,
+      starterTasks: manifest.starterTasks,
       announcements: existsSync21(annPath) ? readFileSync16(annPath, "utf-8") : void 0,
       norms: existsSync21(normsPath) ? readFileSync16(normsPath, "utf-8") : void 0,
       i18n: manifest.i18n
@@ -60101,6 +60556,34 @@ var init_org_service = __esm({
       listHumanUsers(orgId2) {
         return [...this.humans.values()].filter((h) => h.orgId === orgId2);
       }
+      /**
+       * Update (or insert) a user's in-memory identity without touching the DB.
+       * Safe to call from auth endpoints that already persisted DB changes.
+       * Never throws — logs warnings on failure.
+       */
+      syncHumanIdentity(userId2, orgId2, name, role, email) {
+        try {
+          const existing = this.humans.get(userId2);
+          if (existing) {
+            existing.name = name;
+            if (email !== void 0)
+              existing.email = email;
+            existing.role = role;
+          } else {
+            this.humans.set(userId2, {
+              id: userId2,
+              name,
+              email,
+              role,
+              orgId: orgId2,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          this.refreshIdentityContextsForOrg(orgId2);
+        } catch (err) {
+          log49.warn("syncHumanIdentity failed (non-fatal)", { userId: userId2, error: String(err) });
+        }
+      }
       updateHumanUser(userId2, updates) {
         const user = this.humans.get(userId2);
         if (!user)
@@ -61178,10 +61661,12 @@ var init_task_service = __esm({
             }
           }
           if (!isReviewerDuringReview) {
-            if (task?.assignedAgentId) {
+            const terminalStatuses = /* @__PURE__ */ new Set(["completed", "accepted", "archived"]);
+            const handledByInjection = task?.status === "in_progress" || task?.status && terminalStatuses.has(task.status);
+            if (task?.assignedAgentId && !handledByInjection) {
               enqueueFor(task.assignedAgentId, "task_comment", `New comment from ${authorName} on your assigned task`);
             }
-            if (task?.createdBy && task.status !== "in_progress") {
+            if (task?.createdBy && !handledByInjection) {
               enqueueFor(task.createdBy, "task_comment", `New comment from ${authorName} on a task you created`);
             }
           }
@@ -62407,14 +62892,15 @@ ${c.content}`;
           reviewer: task.reviewerId
         });
         if (this.hitlService && request.creatorRole !== "human" && task.status === "pending") {
-          const creatorName = request.createdBy ?? "unknown agent";
+          const creatorId = request.createdBy ?? "system";
+          const creatorName = this.resolveActorName(creatorId, "agent") ?? creatorId;
           this.hitlService.requestApprovalAndWait({
-            agentId: request.createdBy ?? "system",
+            agentId: creatorId,
             agentName: creatorName,
             type: "custom",
-            title: `Task approval: ${task.title}`,
+            title: task.title,
             description: `Agent "${creatorName}" wants to create task "${task.title}" (priority: ${task.priority}).`,
-            details: { taskId: task.id, priority: task.priority }
+            details: { taskId: task.id, taskTitle: task.title, priority: task.priority, subType: "task" }
           }).then((result) => {
             const current = this.tasks.get(task.id);
             if (!current || current.status !== "pending")
@@ -62653,6 +63139,12 @@ ${c.content}`;
         if (from === "review" && to !== "review") {
           this.activeReviews.delete(taskId2);
         }
+        if (TERMINAL_STATUSES.has(to) && this.hitlService) {
+          const cancelled = this.hitlService.cancelApprovalsByDetail("taskId", taskId2, "system", `Task ${to}`);
+          if (cancelled > 0) {
+            log50.info(`Cancelled ${cancelled} pending approval(s) for task ${taskId2} (status \u2192 ${to})`);
+          }
+        }
       }
       // ─── Stage 2: DB persistence ─────────────────────────────────────────────────
       persistStatusChange(id, status, updatedBy) {
@@ -62701,12 +63193,14 @@ ${c.content}`;
 Deliverables:
 ${deliverablesSummary}` : ""
         ].filter(Boolean).join("\n");
+        const assigneeName = this.resolveActorName(task.assignedAgentId, "agent") ?? task.assignedAgentId;
         this.hitlService.requestApprovalAndWait({
           agentId: task.assignedAgentId,
-          agentName: task.assignedAgentId,
+          agentName: assigneeName,
           type: "custom",
           title: `Review: ${task.title}`,
           description,
+          details: { taskId: task.id, taskTitle: task.title, subType: "task_review" },
           targetUserId: task.reviewerId,
           options: [
             { id: "approve", label: "Approve" },
@@ -63061,6 +63555,12 @@ Action: ${guidance}` : ""
         if (data.reviewerType !== void 0)
           task.reviewerType = data.reviewerType;
         if (data.blockedBy !== void 0) {
+          if (data.blockedBy.length > 0) {
+            const cycle = this.detectBlockedByCycle(id, data.blockedBy);
+            if (cycle) {
+              throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}. Cannot set blocked_by \u2014 this would create a deadlock.`);
+            }
+          }
           task.blockedBy = data.blockedBy;
           if (this.taskRepo && "updateBlockedBy" in this.taskRepo) {
             this.taskRepo.updateBlockedBy(id, data.blockedBy).catch((err) => log50.warn("Failed to persist blockedBy to DB", { error: String(err) }));
@@ -63185,6 +63685,31 @@ Action: ${guidance}` : ""
           this.cascadeCancelDependents(task);
         }
       }
+      /**
+       * Detect cycles in blocked_by dependencies using BFS.
+       * Returns the cycle path if found, or null if no cycle exists.
+       */
+      detectBlockedByCycle(taskId2, proposedBlockers) {
+        for (const blockerId of proposedBlockers) {
+          const visited = /* @__PURE__ */ new Set();
+          const queue = [{ id: blockerId, path: [taskId2, blockerId] }];
+          while (queue.length > 0) {
+            const { id: current, path } = queue.shift();
+            if (current === taskId2)
+              return path;
+            if (visited.has(current))
+              continue;
+            visited.add(current);
+            const blockerTask = this.tasks.get(current);
+            if (blockerTask?.blockedBy) {
+              for (const nextId of blockerTask.blockedBy) {
+                queue.push({ id: nextId, path: [...path, nextId] });
+              }
+            }
+          }
+        }
+        return null;
+      }
       areBlockersSatisfied(task) {
         if (!task.blockedBy?.length)
           return true;
@@ -63704,7 +64229,7 @@ Action: ${guidance}` : ""
           "",
           'Save each lesson using `memory_save` with tags `["lesson", ...]`.',
           'If it is a repeatable multi-step procedure, promote to SOP via `memory_update_longterm({ section: "sops", mode: "patch" })`.',
-          "If the best practice would benefit other agents on the team, create a shareable skill via **skill-building** and install it with `builder_install`.",
+          "If the best practice would benefit other agents on the team, create a shareable skill via **skill-building** and install it with `package_install`.",
           "",
           "**Direct self-evolution** \u2014 consider the simplest, most impactful options:",
           "- If this lesson reveals a behavioral rule that should always guide your work, append it to your ROLE.md via `file_edit`.",
@@ -63724,7 +64249,7 @@ Action: ${guidance}` : ""
           "",
           'If you identify a meaningful insight, save it using `memory_save` with tags `["lesson", "best-practice", ...]`.',
           'If it is a multi-step workflow, promote to SOP via `memory_update_longterm({ section: "sops", mode: "patch" })`.',
-          "If worth sharing with the team, create a skill via **skill-building** and install with `builder_install`.",
+          "If worth sharing with the team, create a skill via **skill-building** and install with `package_install`.",
           "",
           "**Direct self-evolution** \u2014 consider the simplest, most impactful options:",
           "- If this success reveals a guiding principle or working style worth keeping, append it to your ROLE.md via `file_edit`.",
@@ -63977,7 +64502,7 @@ ${reason}`
           updated.runAt = void 0;
         }
         if (fields.maxRuns !== void 0)
-          updated.maxRuns = fields.maxRuns;
+          updated.maxRuns = fields.maxRuns > 0 ? fields.maxRuns : void 0;
         if (fields.timezone !== void 0)
           updated.timezone = fields.timezone;
         updated.nextRunAt = computeNextRunFromConfig(updated);
@@ -64347,8 +64872,10 @@ ${task.description}`;
           content,
           "",
           `(This task "${task.title}" is already ${task.status}. You have full context from your execution above.`,
-          "Respond to the comment. If the feedback contains something worth remembering, save it to memory.",
-          "You have all your tools available \u2014 take action if appropriate.)"
+          "Your text response will be posted as a reply in the task comment thread automatically.",
+          "Do NOT use the `task_comment` tool \u2014 your text output IS the reply visible to the commenter.",
+          "If the feedback contains something worth remembering, save it to memory.",
+          "You have all your tools available for taking action if appropriate.)"
         ].join("\n");
         try {
           log50.info("Triggering post-task agent reply", { taskId: taskId2, taskSessionId, agentId: agentId2, authorName });
@@ -64460,11 +64987,19 @@ var init_builder_service = __esm({
       orgService;
       skillRegistry;
       wsBroadcast;
+      taskService;
+      builtinTeamTemplatesDir;
       constructor(orgService, skillRegistry, wsBroadcast) {
         this.orgService = orgService;
         this.skillRegistry = skillRegistry;
         this.wsBroadcast = wsBroadcast;
       }
+      setTaskService(taskService) {
+        this.taskService = taskService;
+      }
+      setBuiltinTeamTemplatesDir(dir) {
+        this.builtinTeamTemplatesDir = dir;
+      }
       get baseDir() {
         return join20(homedir12(), ".markus", "builder-artifacts");
       }
@@ -64497,14 +65032,42 @@ var init_builder_service = __esm({
             });
           }
         }
+        if ((!type || type === "team") && this.builtinTeamTemplatesDir && existsSync24(this.builtinTeamTemplatesDir)) {
+          const artifactNames = new Set(artifacts.filter((a) => a.type === "team").map((a) => a.name));
+          for (const entry of readdirSync8(this.builtinTeamTemplatesDir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || artifactNames.has(entry.name))
+              continue;
+            const tplDir = join20(this.builtinTeamTemplatesDir, entry.name);
+            const manifest = readManifest(tplDir, "team", FS_HELPER);
+            if (!manifest)
+              continue;
+            artifacts.push({
+              type: "team",
+              name: entry.name,
+              description: manifest.description ?? void 0,
+              meta: { ...manifest, source: "builtin" },
+              path: tplDir,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
         artifacts.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
         return artifacts;
       }
       async installArtifact(type, name) {
         const typeDir = type === "agent" ? "agents" : type === "team" ? "teams" : "skills";
-        const artDir = join20(this.baseDir, typeDir, name);
+        let artDir = join20(this.baseDir, typeDir, name);
         if (!existsSync24(artDir)) {
-          throw new Error(`Artifact not found: ${type}/${name}`);
+          if (type === "team" && this.builtinTeamTemplatesDir) {
+            const builtinDir = join20(this.builtinTeamTemplatesDir, name);
+            if (existsSync24(builtinDir)) {
+              artDir = builtinDir;
+            } else {
+              throw new Error(`Team template not found: ${name}. Use package_list to see available packages.`);
+            }
+          } else {
+            throw new Error(`Artifact not found: ${type}/${name}`);
+          }
         }
         const installType = type;
         const manifest = readManifest(artDir, installType, FS_HELPER);
@@ -64620,9 +65183,35 @@ var init_builder_service = __esm({
             createdAgents.push({ id: agent.id, name: agent.config.name, role: agent.role.name });
           }
         }
+        const starterTasks = manifest.starterTasks ?? manifest.team?.starterTasks ?? [];
+        const createdTaskIds = [];
+        if (starterTasks.length > 0 && this.taskService) {
+          const managerId = createdAgents.find((a) => a.role === "manager" || members.find((m) => m.name === a.name)?.role === "manager")?.id ?? createdAgents[0]?.id;
+          if (managerId) {
+            for (const st of starterTasks) {
+              try {
+                const task = this.taskService.createTask({
+                  orgId: "default",
+                  title: st.title,
+                  description: st.description,
+                  priority: st.priority ?? "medium",
+                  assignedAgentId: managerId,
+                  reviewerId: managerId,
+                  reviewerType: "human",
+                  creatorRole: "human",
+                  taskType: "standard"
+                });
+                createdTaskIds.push(task.id);
+                log51.info("installTeam: created starterTask", { taskId: task.id, title: st.title });
+              } catch (err) {
+                log51.warn("installTeam: failed to create starterTask", { title: st.title, error: String(err) });
+              }
+            }
+          }
+        }
         return {
           type: "team",
-          installed: { team: { id: team.id, name: teamName }, agents: createdAgents }
+          installed: { team: { id: team.id, name: teamName }, agents: createdAgents, starterTaskIds: createdTaskIds }
         };
       }
       /**
@@ -65221,7 +65810,12 @@ var init_sse_handler = __esm({
               replyLength: persistReply.length
             });
             if (this.options.wsBroadcaster) {
-              this.options.wsBroadcaster.broadcastChat(this.options.agentId, persistReply, "agent");
+              if (this.options.wsBroadcaster.broadcastProactiveMessage && this.sessionId) {
+                const agentName = this.options.agent.config?.name ?? this.options.agentId;
+                this.options.wsBroadcaster.broadcastProactiveMessage(this.options.agentId, agentName, this.sessionId, `ws_fallback_${Date.now()}`, persistReply, { isMainSession: true }, this.options.senderId);
+              } else {
+                this.options.wsBroadcaster.broadcastChat(this.options.agentId, persistReply, "agent");
+              }
             }
           } else {
             this.sseBuffer.send({
@@ -65943,7 +66537,7 @@ var init_api_server = __esm({
                 let channelContext = [];
                 if (this.storage) {
                   try {
-                    const recent = await this.storage.channelMessageRepo.getMessages(channelKey, 20);
+                    const recent = await this.storage.channelMessageRepo.getMessages(channelKey, 80);
                     channelContext = (recent.messages ?? []).map((m) => ({
                       role: m.senderType === "agent" ? "assistant" : "user",
                       content: m.senderType === "agent" ? stripInternalBlocks(m.text) : `[${m.senderName}]: ${m.text}`
@@ -66036,6 +66630,7 @@ ${cleanText}`,
       setSkillRegistry(registry) {
         this.skillRegistry = registry;
         this.builderService = new BuilderService(this.orgService, registry, (msg) => this.ws?.broadcast(msg));
+        this.builderService.setTaskService(this.taskService);
       }
       getBuilderService() {
         return this.builderService;
@@ -66513,13 +67108,33 @@ ${cleanText}`,
             toolEventCollector: toolEvents,
             waitForReply: isA2A ? true : void 0
           });
+          const emitNoResponse = () => {
+            const evt = {
+              type: "chat:agent_no_response",
+              payload: { channel, agentId: agentId2 },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            if (channel.startsWith("dm:") || channel.startsWith("notes:")) {
+              const parts = channel.startsWith("notes:") ? [channel.slice(6)] : channel.slice(3).split(":");
+              this.ws.sendToUsers(parts, evt);
+            } else {
+              const humanIds = this.resolveChannelHumanIds(channel);
+              if (humanIds.length > 0)
+                this.ws.sendToUsers(humanIds, evt);
+              else
+                this.ws.broadcast(evt);
+            }
+          };
           if (!reply || !reply.trim() || reply.includes("[NO_RESPONSE]")) {
+            emitNoResponse();
             return;
           }
           const { thinking, clean: rawClean } = extractThinkBlocks(reply);
           const cleanReply = rawClean.replace(/\[NO_RESPONSE\]/gi, "").trim();
-          if (!cleanReply)
+          if (!cleanReply) {
+            emitNoResponse();
             return;
+          }
           const metadata = {};
           if (thinking.length > 0)
             metadata["thinking"] = thinking;
@@ -66622,7 +67237,7 @@ ${cleanText}`,
         let channelContext = [];
         if (this.storage) {
           try {
-            const recent = await this.storage.channelMessageRepo.getMessages(channel, 20);
+            const recent = await this.storage.channelMessageRepo.getMessages(channel, 80);
             channelContext = (recent.messages ?? []).map((m) => ({
               role: m.senderType === "agent" ? "assistant" : "user",
               content: m.senderType === "agent" ? stripInternalBlocks(m.text) : `[${m.senderName}]: ${m.text}`
@@ -66688,6 +67303,24 @@ ${cleanText}`,
           log56.warn("Failed to persist assistant message", { error: String(err) });
         }
       }
+      triggerSecretaryWelcome(userId2, userName, userRole) {
+        try {
+          const mgr = this.orgService.getAgentManager();
+          const agentList = mgr.listAgents();
+          const secretaryInfo = agentList.find((a) => a.agentRole === "secretary" || a.role?.toLowerCase() === "secretary");
+          if (!secretaryInfo)
+            return;
+          const secretary = mgr.getAgent(secretaryInfo.id);
+          const welcomeMsg = `[SYSTEM] A new team member just joined: "${userName}" (role: ${userRole}, id: ${userId2}). They have completed their account setup. As their Secretary, proactively guide them through the system capabilities. Send them a welcome message using notify_user (target the new user by their id: ${userId2}) explaining what they can do in Markus \u2014 projects, tasks, deliverables, team collaboration, and how to work with AI agents. Help them get started with their first steps.`;
+          secretary.sendMessage(welcomeMsg, userId2, {
+            name: userName,
+            role: userRole,
+            isFirstConversation: true
+          }, { sourceType: "human_chat", scenario: "chat" });
+        } catch (err) {
+          log56.warn("Failed to trigger secretary welcome for new user", { userId: userId2, error: String(err) });
+        }
+      }
       start() {
         this.server = createServer2((req, res) => this.handleRequest(req, res));
         this.ws.attach(this.server);
@@ -66750,6 +67383,68 @@ ${cleanText}`,
             await this.readBody(req);
           }
         }
+        if (path === "/api/auth/status" && req.method === "GET") {
+          if (!this.storage || !this.authEnabled) {
+            this.json(res, 200, { initialized: true });
+            return;
+          }
+          const allUsers = await this.storage.userRepo.listByOrg("default");
+          const hasRealUsers = allUsers.some((u) => u.passwordHash && u.email !== "admin@markus.local");
+          this.json(res, 200, { initialized: hasRealUsers });
+          return;
+        }
+        if (path === "/api/auth/init" && req.method === "POST") {
+          if (!this.storage) {
+            this.json(res, 503, { error: "Storage not available" });
+            return;
+          }
+          const allUsers = await this.storage.userRepo.listByOrg("default");
+          const hasRealUsers = allUsers.some((u) => u.passwordHash && u.email !== "admin@markus.local");
+          if (hasRealUsers) {
+            this.json(res, 403, { error: "System already initialized" });
+            return;
+          }
+          const body = await this.readBody(req);
+          const name = (body["name"] ?? "").trim();
+          const email = (body["email"] ?? "").trim().toLowerCase();
+          const password = body["password"] ?? "";
+          if (!name || !email || !password) {
+            this.json(res, 400, { error: "name, email and password are required" });
+            return;
+          }
+          if (password.length < 6) {
+            this.json(res, 400, { error: "Password must be at least 6 characters" });
+            return;
+          }
+          const hash = await hashPassword(password);
+          const placeholder = allUsers.find((u) => u.role === "owner" && u.email === "admin@markus.local");
+          let userId2;
+          if (placeholder) {
+            userId2 = placeholder.id;
+            this.storage.userRepo.updateProfile(userId2, { name, email });
+            await this.storage.userRepo.updatePassword(userId2, hash);
+          } else {
+            userId2 = userId();
+            await this.storage.userRepo.upsert({
+              id: userId2,
+              orgId: "default",
+              name,
+              email,
+              role: "owner",
+              passwordHash: hash
+            });
+          }
+          this.orgService.syncHumanIdentity(userId2, "default", name, "owner", email);
+          await this.storage.userRepo.updateLastLogin(userId2);
+          const exp = Math.floor(Date.now() / 1e3) + 7 * 24 * 3600;
+          const token = await signToken({ userId: userId2, orgId: "default", role: "owner", exp }, this.jwtSecret);
+          res.setHeader("Set-Cookie", `markus_token=${token}; HttpOnly; SameSite=Strict; Path=/; Max-Age=${7 * 24 * 3600}`);
+          this.json(res, 200, {
+            user: { id: userId2, name, email, role: "owner", orgId: "default" },
+            needsOnboarding: true
+          });
+          return;
+        }
         if (path === "/api/auth/login" && req.method === "POST") {
           const body = await this.readBody(req);
           const email = (body["email"] ?? "").trim().toLowerCase();
@@ -66758,7 +67453,18 @@ ${cleanText}`,
             this.json(res, 200, { user: { id: "anonymous", name: "Admin", role: "owner" } });
             return;
           }
-          const userRow = this.storage ? await this.storage.userRepo.findByEmail(email) : null;
+          let userRow = this.storage ? await this.storage.userRepo.findByEmail(email) : null;
+          if (!userRow && this.storage) {
+            const allUsers = await this.storage.userRepo.listByOrg("default");
+            const unclaimedOwner = allUsers.find((u) => u.role === "owner" && !u.lastLoginAt && u.email === "admin@markus.local");
+            if (unclaimedOwner && unclaimedOwner.passwordHash) {
+              const ownerPasswordValid = await verifyPassword(password, unclaimedOwner.passwordHash);
+              if (ownerPasswordValid) {
+                this.storage.userRepo.updateProfile(unclaimedOwner.id, { email });
+                userRow = { ...unclaimedOwner, email };
+              }
+            }
+          }
           if (!userRow || !userRow.passwordHash) {
             this.json(res, 401, { error: "Invalid email or password" });
             return;
@@ -66768,6 +67474,7 @@ ${cleanText}`,
             this.json(res, 401, { error: "Invalid email or password" });
             return;
           }
+          const isFirstLogin = !userRow.lastLoginAt;
           await this.storage.userRepo.updateLastLogin(userRow.id);
           const exp = Math.floor(Date.now() / 1e3) + 7 * 24 * 3600;
           const token = await signToken({ userId: userRow.id, orgId: userRow.orgId, role: userRow.role, exp }, this.jwtSecret);
@@ -66780,7 +67487,8 @@ ${cleanText}`,
               role: userRow.role,
               orgId: userRow.orgId,
               avatarUrl: userRow.avatarUrl ?? void 0
-            }
+            },
+            needsOnboarding: isFirstLogin
           });
           return;
         }
@@ -67072,6 +67780,18 @@ ${cleanText}`,
           }
           return;
         }
+        if (path === "/api/sessions/has-any" && req.method === "GET") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
+          if (!this.storage) {
+            this.json(res, 200, { hasAny: false });
+            return;
+          }
+          const hasAny = this.storage.chatSessionRepo.hasAnySessions(authUser.userId);
+          this.json(res, 200, { hasAny });
+          return;
+        }
         if (path.match(/^\/api\/agents\/[^/]+\/sessions$/) && req.method === "GET") {
           const authUser = await this.getAuthUser(req);
           const agentId2 = path.split("/")[3];
@@ -67162,7 +67882,7 @@ ${cleanText}`,
             if (!this.storage)
               return [];
             try {
-              const recent = await this.storage.channelMessageRepo.getMessages(channel, 20);
+              const recent = await this.storage.channelMessageRepo.getMessages(channel, 80);
               return (recent.messages ?? []).map((m) => ({
                 role: m.senderType === "agent" ? "assistant" : "user",
                 content: m.senderType === "agent" ? stripInternalBlocks(m.text) : `[${m.senderName}]: ${m.text}`
@@ -67486,7 +68206,9 @@ ${cleanText}`,
             const fileNames = body["fileNames"]?.filter(Boolean);
             const isRetry = body["isRetry"];
             const isResume = body["isResume"];
-            const senderInfo = this.orgService.resolveHumanIdentity(senderId);
+            const baseSenderInfo = this.orgService.resolveHumanIdentity(senderId);
+            const isFirstConversation = this.storage ? !this.storage.chatSessionRepo.hasAnySessions(senderId) : false;
+            const senderInfo = baseSenderInfo ? { ...baseSenderInfo, isFirstConversation } : void 0;
             const agent = this.orgService.getAgentManager().getAgent(agentId2);
             this.ws.broadcastAgentUpdate(agentId2, "working");
             if (!sessionId) {
@@ -67599,9 +68321,15 @@ ${cleanText}`,
           return;
         }
         if (path === "/api/group-chats" && req.method === "GET") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
           const orgId2 = url.searchParams.get("orgId") ?? "default";
+          const userId2 = authUser.userId;
+          const isAdmin = authUser.role === "owner" || authUser.role === "admin";
           const teams = this.orgService.listTeamsWithMembers(orgId2);
-          const teamChats = teams.map((t) => ({
+          const filteredTeams = isAdmin ? teams : teams.filter((t) => t.members.some((m) => m.id === userId2));
+          const teamChats = filteredTeams.map((t) => ({
             id: `group:${t.id}`,
             name: t.name,
             type: "team",
@@ -67609,7 +68337,7 @@ ${cleanText}`,
             memberCount: t.members.length,
             channelKey: `group:${t.id}`
           }));
-          const customChats = this.storage?.groupChatRepo ? this.storage.groupChatRepo.list(orgId2).map((c) => ({
+          const customChats = this.storage?.groupChatRepo ? (isAdmin ? this.storage.groupChatRepo.list(orgId2) : this.storage.groupChatRepo.listByMember(orgId2, userId2)).map((c) => ({
             id: c.id,
             name: c.name,
             type: "custom",
@@ -71345,6 +72073,50 @@ EXPLANATION_END`;
           this.json(res, 200, { success: read ?? false });
           return;
         }
+        if (path === "/api/activity" && req.method === "GET") {
+          const authUser = await this.requireAuth(req, res);
+          if (!authUser)
+            return;
+          const userId2 = authUser.userId;
+          const limit = Math.min(parseInt(url.searchParams.get("limit") ?? "50", 10), 200);
+          const typeFilter = url.searchParams.get("type") ?? void 0;
+          const items = [];
+          if (!typeFilter || typeFilter === "notification") {
+            const notifications = this.hitlService?.listNotifications(userId2, false, { limit }) ?? [];
+            for (const n of notifications) {
+              items.push({
+                id: n.id,
+                type: n.type,
+                title: n.title,
+                body: n.body,
+                timestamp: n.createdAt,
+                source: "notification",
+                metadata: n.metadata
+              });
+            }
+          }
+          if ((!typeFilter || typeFilter === "task_comment") && this.storage?.taskCommentRepo) {
+            try {
+              const recentComments = this.storage.taskCommentRepo.listRecent?.(limit) ?? [];
+              for (const c of recentComments) {
+                items.push({
+                  id: c.id,
+                  type: "task_comment",
+                  title: `Comment on task ${c.taskId}`,
+                  body: typeof c.body === "string" ? c.body.slice(0, 300) : String(c.body ?? ""),
+                  timestamp: c.createdAt,
+                  source: "task_comment",
+                  metadata: { taskId: c.taskId, authorId: c.authorId, authorName: c.authorName }
+                });
+              }
+            } catch {
+            }
+          }
+          items.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+          const page = items.slice(0, limit);
+          this.json(res, 200, { items: page, totalCount: items.length });
+          return;
+        }
         if (path === "/api/usage" && req.method === "GET") {
           const orgId2 = url.searchParams.get("orgId") ?? "default";
           const plan = this.billingService?.getOrgPlan(orgId2);
@@ -73980,6 +74752,8 @@ EXPLANATION_END`;
           exact("/api/notifications", "GET"),
           exact("/api/notifications/mark-all-read", "POST"),
           startsWith("/api/notifications/", "POST"),
+          // ── Activity feed ─────────────────────────────────────────────────
+          exact("/api/activity", "GET"),
           // ── Users ────────────────────────────────────────────────────────────
           exact("/api/users", "GET", "POST"),
           regex(/^\/api\/users\/[^/]+$/, "PATCH"),
@@ -74595,7 +75369,7 @@ var init_hitl_service = __esm({
         this.notify({
           targetUserId: opts.targetUserId ?? "all",
           type: "approval_request",
-          title: `Approval needed: ${opts.title}`,
+          title: opts.title,
           body: opts.description,
           priority: "high",
           actionType: "navigate",
@@ -74612,6 +75386,14 @@ var init_hitl_service = __esm({
             setTimeout(() => {
               if (this.pendingResolvers.has(approval.id)) {
                 this.pendingResolvers.delete(approval.id);
+                const a = this.approvals.get(approval.id);
+                if (a && a.status === "pending") {
+                  a.status = "expired";
+                  a.respondedAt = (/* @__PURE__ */ new Date()).toISOString();
+                  a.responseComment = "Approval timed out";
+                  this.persistApproval(a);
+                  this.markApprovalNotificationsRead(a.id);
+                }
                 resolve20({ approved: false, comment: "Approval timed out" });
               }
             }, opts.expiresInMs);
@@ -74639,6 +75421,35 @@ var init_hitl_service = __esm({
         }
         return approval;
       }
+      cancelApproval(id, cancelledBy, comment) {
+        const approval = this.approvals.get(id);
+        if (!approval || approval.status !== "pending")
+          return void 0;
+        approval.status = "cancelled";
+        approval.respondedAt = (/* @__PURE__ */ new Date()).toISOString();
+        approval.respondedBy = cancelledBy;
+        if (comment)
+          approval.responseComment = comment;
+        this.persistApproval(approval);
+        log57.info(`Approval ${id} cancelled by ${cancelledBy}`, { comment });
+        this.markApprovalNotificationsRead(id);
+        const resolve20 = this.pendingResolvers.get(id);
+        if (resolve20) {
+          this.pendingResolvers.delete(id);
+          resolve20({ approved: false, comment: comment ?? "Approval cancelled" });
+        }
+        return approval;
+      }
+      cancelApprovalsByDetail(key2, value, cancelledBy, comment) {
+        let count = 0;
+        for (const approval of this.approvals.values()) {
+          if (approval.status === "pending" && approval.details[key2] === value) {
+            this.cancelApproval(approval.id, cancelledBy, comment);
+            count++;
+          }
+        }
+        return count;
+      }
       persistApproval(approval) {
         if (!this.approvalRepo)
           return;
@@ -75469,13 +76280,14 @@ var init_requirement_service = __esm({
         }
         this.broadcast("requirement:created", req);
         if (this.hitlService && req.source === "agent") {
+          const creatorName = this.resolveAgentName(req.createdBy);
           this.hitlService.requestApprovalAndWait({
             agentId: req.createdBy,
-            agentName: req.createdBy,
+            agentName: creatorName,
             type: "custom",
-            title: `Requirement approval: ${req.title}`,
-            description: `Agent "${req.createdBy}" proposed requirement "${req.title}" (priority: ${req.priority}).`,
-            details: { requirementId: req.id, priority: req.priority },
+            title: req.title,
+            description: `Agent "${creatorName}" proposed requirement "${req.title}" (priority: ${req.priority}).`,
+            details: { requirementId: req.id, priority: req.priority, subType: "requirement" },
             targetUserId: "all"
           }).then((result) => {
             const current = this.requirements.get(req.id);
@@ -75611,13 +76423,14 @@ var init_requirement_service = __esm({
         this.broadcast("requirement:resubmitted", req);
         log61.info("Requirement resubmitted for review", { id, hasUpdates: !!updates });
         if (this.hitlService && req.source === "agent") {
+          const creatorName = this.resolveAgentName(req.createdBy);
           this.hitlService.requestApprovalAndWait({
             agentId: req.createdBy,
-            agentName: req.createdBy,
+            agentName: creatorName,
             type: "custom",
-            title: `Requirement approval (resubmitted): ${req.title}`,
-            description: `Agent "${req.createdBy}" resubmitted requirement "${req.title}" (priority: ${req.priority}).`,
-            details: { requirementId: req.id, priority: req.priority },
+            title: req.title,
+            description: `Agent "${creatorName}" resubmitted requirement "${req.title}" (priority: ${req.priority}).`,
+            details: { requirementId: req.id, priority: req.priority, subType: "requirement_resubmit" },
             targetUserId: "all"
           }).then((result) => {
             const current = this.requirements.get(req.id);
@@ -75791,6 +76604,9 @@ var init_requirement_service = __esm({
         const req = this.requirements.get(id);
         if (!req)
           throw new Error(`Requirement ${id} not found`);
+        if (this.hitlService) {
+          this.hitlService.cancelApprovalsByDetail("requirementId", id, cancelledBy ?? "system", "Requirement cancelled");
+        }
         const oldStatus = req.status;
         req.status = "cancelled";
         req.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -75884,6 +76700,9 @@ var init_requirement_service = __esm({
         }
       }
       deleteRequirement(id) {
+        if (this.hitlService) {
+          this.hitlService.cancelApprovalsByDetail("requirementId", id, "system", "Requirement deleted");
+        }
         this.requirements.delete(id);
         if (this.requirementRepo) {
           this.requirementRepo.delete(id).catch((e) => log61.error("Failed to delete requirement from storage", { id, error: String(e) }));
@@ -75955,6 +76774,17 @@ var init_requirement_service = __esm({
           });
         }
       }
+      resolveAgentName(agentId2) {
+        if (this.agentManager) {
+          try {
+            const agent = this.agentManager.getAgent(agentId2);
+            if (agent)
+              return agent.config?.name ?? agent.name ?? agentId2;
+          } catch {
+          }
+        }
+        return agentId2;
+      }
       broadcast(type, data) {
         if (this.ws) {
           this.ws.broadcast({
@@ -77106,13 +77936,19 @@ var init_stale_detector = __esm({
       taskService;
       config;
       scanInterval;
-      constructor(taskService, config) {
+      onStaleItems;
+      constructor(taskService, config, onStaleItems) {
         this.taskService = taskService;
         this.config = { ...DEFAULT_CONFIG4, ...config };
+        this.onStaleItems = onStaleItems;
       }
       start(intervalMs = 36e5) {
         this.scanInterval = setInterval(() => {
-          this.scan().catch((err) => log68.warn("Stale scan failed", { error: String(err) }));
+          this.scan().then((items) => {
+            if (items.length > 0 && this.onStaleItems) {
+              this.onStaleItems(items);
+            }
+          }).catch((err) => log68.warn("Stale scan failed", { error: String(err) }));
         }, intervalMs);
         log68.info("Stale detector started", { intervalMs });
       }
@@ -77208,7 +78044,7 @@ var init_scheduled_task_runner = __esm({
           if (!task.scheduleConfig)
             continue;
           const config = task.scheduleConfig;
-          if (config.maxRuns !== void 0 && (config.currentRuns ?? 0) >= config.maxRuns) {
+          if (config.maxRuns && config.maxRuns > 0 && (config.currentRuns ?? 0) >= config.maxRuns) {
             continue;
           }
           const nextRun = config.nextRunAt ? new Date(config.nextRunAt).getTime() : 0;
@@ -78717,6 +79553,10 @@ CREATE INDEX IF NOT EXISTS idx_st_entity ON status_transitions(entity_type, enti
         }
         return this.db.prepare("SELECT * FROM chat_sessions WHERE agent_id = ? ORDER BY is_main DESC, last_message_at DESC LIMIT ?").all(agentId2, limit).map((r) => this._mapSession(r));
       }
+      hasAnySessions(userId2) {
+        const r = this.db.prepare("SELECT 1 FROM chat_sessions WHERE user_id = ? LIMIT 1").get(userId2);
+        return r !== null && r !== void 0;
+      }
       getSession(sessionId) {
         const r = this.db.prepare("SELECT * FROM chat_sessions WHERE id = ?").get(sessionId);
         return r ? this._mapSession(r) : null;
@@ -80187,6 +81027,17 @@ CREATE INDEX IF NOT EXISTS idx_st_entity ON status_transitions(entity_type, enti
           memberCount: r["member_count"]
         }));
       }
+      listByMember(orgId2, memberId) {
+        const rows = this.db.prepare(`SELECT g.*, (SELECT COUNT(*) FROM group_chat_members WHERE group_chat_id = g.id) AS member_count
+       FROM group_chats g
+       INNER JOIN group_chat_members m ON m.group_chat_id = g.id
+       WHERE g.org_id = ? AND m.member_id = ?
+       ORDER BY g.created_at DESC`).all(orgId2, memberId);
+        return rows.map((r) => ({
+          ...this.mapRow(r),
+          memberCount: r["member_count"]
+        }));
+      }
       getById(id) {
         const r = this.db.prepare("SELECT * FROM group_chats WHERE id = ?").get(id);
         if (!r)
@@ -82081,10 +82932,10 @@ function registerStartCommand(program2) {
     const configPath = globalOpts.config ?? getDefaultConfigPath();
     if (opts.setup || !existsSync33(configPath)) {
       if (!existsSync33(configPath)) {
-        console.log("  No configuration found \u2014 running first-time setup...\n");
+        console.log("  No configuration found \u2014 auto-configuring from environment...\n");
       }
       const { quickInit: quickInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-      await quickInit2();
+      await quickInit2({ nonInteractive: true });
     }
     const config = loadConfig(globalOpts.config);
     await startServer(config, { port: globalOpts.port, config: globalOpts.config });
@@ -82327,7 +83178,8 @@ async function startServer(config, values) {
     startupLog("INFO", "  2. \u4EA4\u4E92\u5F0F\u914D\u7F6E    \u2192 \u6B63\u5728\u542F\u52A8\u5411\u5BFC...");
     startupBlank();
     const { quickInit: quickInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-    await quickInit2();
+    startupLog("INFO", "\u81EA\u52A8\u4ECE\u73AF\u5883\u53D8\u91CF/\u5DF2\u77E5\u914D\u7F6E\u5BFC\u5165 LLM \u8BBE\u7F6E...");
+    await quickInit2({ nonInteractive: true });
     const { loadConfig: reloadConfig } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     const updatedConfig = reloadConfig(values["config"]);
     for (const [name, cfg] of Object.entries(updatedConfig.llm?.providers ?? {})) {
@@ -82442,6 +83294,21 @@ async function startServer(config, values) {
   const archiveService = new ArchiveService(taskService, projectService);
   archiveService.setRequirementService(requirementService);
   archiveService.start();
+  const staleDetector = new StaleDetector(taskService, void 0, (items) => {
+    for (const item of items) {
+      hitlService.notify({
+        targetUserId: "all",
+        type: "system",
+        title: item.type === "review_stale" ? "Stale review" : item.type === "stuck_task" ? "Stuck task" : "Unstarted task",
+        body: item.message,
+        priority: item.type === "review_stale" ? "high" : "normal",
+        actionType: item.taskId ? "navigate" : "none",
+        actionTarget: item.taskId ? JSON.stringify({ path: `/work?openTask=${item.taskId}` }) : void 0,
+        metadata: { taskId: item.taskId, agentId: item.agentId, staleType: item.type }
+      });
+    }
+  });
+  staleDetector.start();
   apiServer.setLLMRouter(llmRouter);
   apiServer.setConfigPath(values["config"] ?? getDefaultConfigPath());
   if (config.hub?.url) apiServer.setHubUrl(config.hub.url);
@@ -82475,6 +83342,10 @@ async function startServer(config, values) {
   orgService.registerBuilderContextProviders(skillRegistry);
   const builderService = apiServer.getBuilderService();
   if (builderService) {
+    const builtinTeamsDir = resolveTemplatesDir("teams");
+    if (builtinTeamsDir && existsSync33(builtinTeamsDir)) {
+      builderService.setBuiltinTeamTemplatesDir(builtinTeamsDir);
+    }
     agentManager.setBuilderService(builderService);
   }
   const hubClient = apiServer.getHubClient();
@@ -82506,6 +83377,7 @@ async function startServer(config, values) {
     return { installed: result.installed, name: result.name, method: result.method };
   });
   agentManager.setUserApprovalRequester(async (opts) => {
+    const taskTitle = opts.relatedTaskId ? taskService.getTask(opts.relatedTaskId)?.title : void 0;
     return hitlService.requestApprovalAndWait({
       agentId: opts.agentId,
       agentName: opts.agentName,
@@ -82515,7 +83387,7 @@ async function startServer(config, values) {
       targetUserId: ownerUserId,
       options: opts.options,
       allowFreeform: opts.allowFreeform,
-      details: { priority: opts.priority, taskId: opts.relatedTaskId }
+      details: { priority: opts.priority, taskId: opts.relatedTaskId, taskTitle }
     });
   });
   agentManager.setUserNotifier((opts) => {
@@ -82591,7 +83463,8 @@ async function startServer(config, values) {
     agentManager.getEventBus().on("agent:notify-user", async (evt) => {
       const { agentId: agentId2, title, body, priority, taskId: taskId2, requirementId: requirementId2, targetUserId } = evt;
       try {
-        const mainSession = storage.chatSessionRepo.getOrCreateMainSession(agentId2, defaultSessionUserId);
+        const sessionUserId = targetUserId || defaultSessionUserId;
+        const mainSession = storage.chatSessionRepo.getOrCreateMainSession(agentId2, sessionUserId);
         const agent = agentManager.getAgent(agentId2);
         const formattedMsg = `**${title}**
 
@@ -82607,7 +83480,7 @@ ${body}`;
         storage.chatSessionRepo.updateLastMessage(mainSession.id);
         ws.broadcastProactiveMessage(agentId2, agent.config.name, mainSession.id, msg.id, formattedMsg, {
           isMainSession: true
-        }, defaultSessionUserId);
+        }, sessionUserId);
         const hasTask = !!taskId2;
         hitlService.notify({
           targetUserId: targetUserId ?? "all",
@@ -82771,13 +83644,14 @@ ${reason}`;
       const reasonMatch = request.reason.match(/requires approval:\s*(.+?)\.?\s*Command:/);
       title = reasonMatch ? `Git: ${reasonMatch[1]}` : "Shell: command approval";
     }
+    const taskTitle = request.taskId ? taskService.getTask(request.taskId)?.title : void 0;
     const result = await hitlService.requestApprovalAndWait({
       agentId: agentId2,
       agentName,
       type: "action",
       title,
       description: request.reason,
-      details: { ...request.toolArgs, toolName: request.toolName, agentId: agentId2, taskId: request.taskId },
+      details: { ...request.toolArgs, toolName: request.toolName, agentId: agentId2, taskId: request.taskId, taskTitle },
       targetUserId: ownerUserId
     });
     auditService.record({
@@ -83278,6 +84152,7 @@ ${reason}`;
     closeStartupLogger();
     closeRuntimeLogger();
     archiveService.stop();
+    staleDetector.stop();
     scheduledTaskRunner.stop();
     apiServer.stop();
     agentManager.shutdown().then(() => messageRouter.disconnectAll()).then(() => process.exit(0)).catch(() => process.exit(1));