chatroom-cli 1.122.1 → 1.123.0

package/dist/index.js

@@ -28478,8 +28478,149 @@ var init_agent_process_manager_service = __esm(() => {
   init_check_agent_slot();
 });
 
+// ../shared/src/domain/team-kind.ts
+var TEAM_PRESET_IDS;
+var init_team_kind = __esm(() => {
+  TEAM_PRESET_IDS = ["duo", "solo"];
+});
+
 // ../shared/src/domain/agent-role.ts
-var init_agent_role = () => {};
+function getBuiltinRolesForTeam(teamId) {
+  const memberships = Object.values(AGENT_ROLE_DEFINITIONS).flatMap((definition) => {
+    const membership = definition.teams.find((entry) => entry.teamId === teamId);
+    return membership ? [{ role: definition.role, order: membership.order }] : [];
+  });
+  const roles = memberships.sort((left3, right3) => left3.order - right3.order).map(({ role }) => role);
+  return roles;
+}
+function normalizeAgentRole(role) {
+  return role.trim().toLowerCase();
+}
+function validateNormalizedRoleName(role) {
+  const normalizedRole = normalizeAgentRole(role);
+  if (normalizedRole.length === 0 || role !== normalizedRole) {
+    throw new Error(`Agent role "${role}" must have a normalized nonempty name`);
+  }
+  return normalizedRole;
+}
+function validateRoleNotReserved(role, normalizedRole) {
+  if (normalizedRole === "user" || normalizedRole === "enhancer") {
+    throw new Error(`Agent role "${role}" is reserved or retired`);
+  }
+}
+function registerUniqueRoleName(role, normalizedRole, roleNames) {
+  if (roleNames.has(normalizedRole)) {
+    throw new Error(`Agent role "${role}" duplicates normalized role "${normalizedRole}"`);
+  }
+  roleNames.add(normalizedRole);
+}
+function validateRoleName(role, roleNames) {
+  const normalizedRole = validateNormalizedRoleName(role);
+  validateRoleNotReserved(role, normalizedRole);
+  registerUniqueRoleName(role, normalizedRole, roleNames);
+}
+function validateRoleLifecycle(definition) {
+  const { role } = definition;
+  if (!Array.isArray(definition.tags) || definition.tags.length !== 1 || !AGENT_ROLE_LIFECYCLE_TAGS.includes(definition.tags[0])) {
+    throw new Error(`Agent role "${role}" must declare exactly one recognized lifecycle tag`);
+  }
+}
+function validateKnownTeam(role, teamId) {
+  if (!TEAM_PRESET_IDS.some((knownTeamId) => knownTeamId === teamId)) {
+    throw new Error(`Agent role "${role}" has unknown team "${String(teamId)}"`);
+  }
+}
+function validateUniqueRoleMembership(role, teamId, membershipsForRole) {
+  if (membershipsForRole.has(teamId)) {
+    throw new Error(`Agent role "${role}" has duplicate membership in team "${teamId}"`);
+  }
+  membershipsForRole.add(teamId);
+}
+function validateMembershipOrder(role, teamId, order) {
+  if (!Number.isSafeInteger(order) || order < 0) {
+    throw new Error(`Agent role "${role}" has invalid order "${String(order)}" for team "${teamId}"`);
+  }
+}
+function registerUniqueTeamOrder(role, teamId, order, teamOrders) {
+  const orders = teamOrders.get(teamId) ?? new Map;
+  const conflictingRole = orders.get(order);
+  if (conflictingRole !== undefined) {
+    throw new Error(`Agent role "${role}" order ${order} for team "${teamId}" conflicts with role "${conflictingRole}"`);
+  }
+  orders.set(order, role);
+  teamOrders.set(teamId, orders);
+}
+function validateMembership(role, membership, membershipsForRole, teamOrders) {
+  const { teamId, order } = membership;
+  validateKnownTeam(role, teamId);
+  validateUniqueRoleMembership(role, teamId, membershipsForRole);
+  validateMembershipOrder(role, teamId, order);
+  registerUniqueTeamOrder(role, teamId, order, teamOrders);
+}
+function validateRoleMemberships(definition, teamOrders) {
+  const { role, teams } = definition;
+  if (!Array.isArray(teams) || teams.length === 0) {
+    throw new Error(`Agent role "${role}" must declare at least one team membership`);
+  }
+  const membershipsForRole = new Set;
+  for (const membership of teams) {
+    validateMembership(role, membership, membershipsForRole, teamOrders);
+  }
+}
+function validateAgentRoleDefinitions(definitions) {
+  const roleNames = new Set;
+  const teamOrders = new Map;
+  for (const definition of definitions) {
+    validateRoleName(definition.role, roleNames);
+    validateRoleLifecycle(definition);
+    validateRoleMemberships(definition, teamOrders);
+  }
+}
+var AGENT_ROLE_LIFECYCLE_TAGS, roleMetadata, AGENT_ROLE_DEFINITIONS;
+var init_agent_role = __esm(() => {
+  init_team_kind();
+  AGENT_ROLE_LIFECYCLE_TAGS = [
+    "permanent" /* Permanent */,
+    "ephemeral" /* Ephemeral */
+  ];
+  roleMetadata = {
+    planner: {
+      tags: ["permanent" /* Permanent */],
+      teams: [{ teamId: "duo", order: 10 }]
+    },
+    builder: {
+      tags: ["permanent" /* Permanent */],
+      teams: [{ teamId: "duo", order: 50 }]
+    },
+    solo: {
+      tags: ["permanent" /* Permanent */],
+      teams: [{ teamId: "solo", order: 10 }]
+    },
+    architect: {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [
+        { teamId: "duo", order: 20 },
+        { teamId: "solo", order: 20 }
+      ]
+    },
+    triage: {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [
+        { teamId: "duo", order: 30 },
+        { teamId: "solo", order: 30 }
+      ]
+    },
+    "uiux-engineer": {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [
+        { teamId: "duo", order: 40 },
+        { teamId: "solo", order: 40 }
+      ]
+    }
+  };
+  AGENT_ROLE_DEFINITIONS = Object.fromEntries(Object.entries(roleMetadata).map(([role, metadata]) => [role, { role, ...metadata }]));
+  validateAgentRoleDefinitions(Object.values(AGENT_ROLE_DEFINITIONS));
+});
 
 // ../../services/backend/src/domain/entities/chatroom-workspace-task-inbox.ts
 var ephemeralAssigneeValidator, permanentAssigneeValidator, workspaceTaskAssigneeValidator, workspaceTaskInboxEventStatusValidator, workspaceTaskInboxTaskValidator, workspaceTaskInboxEventFields, workspaceTaskInboxEventValidator;
@@ -107407,10 +107548,11 @@ function getTeamPreset(teamId) {
 function listTeamPresetIds() {
   return [...TEAM_PRESET_IDS];
 }
-var TEAM_PRESET_IDS, DEFAULT_TEAM_PRESET_ID = "duo", TEAM_STRUCTURE_IDS, TEAM_PRESETS;
+var DEFAULT_TEAM_PRESET_ID = "duo", TEAM_STRUCTURE_IDS, TEAM_PRESETS;
 var init_team_presets = __esm(() => {
   init_agent_role();
-  TEAM_PRESET_IDS = ["duo", "solo"];
+  init_team_kind();
+  init_team_kind();
   TEAM_STRUCTURE_IDS = {
     duo: "duo@1",
     solo: "solo@1"
@@ -107419,15 +107561,15 @@ var init_team_presets = __esm(() => {
     duo: {
       structureId: TEAM_STRUCTURE_IDS.duo,
       name: "Duo",
-      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect and optional ephemeral uiux-engineer roles",
-      roles: ["planner", "architect", "uiux-engineer", "builder"],
+      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect, triage, and uiux-engineer roles",
+      roles: getBuiltinRolesForTeam("duo"),
       entryPoint: "planner"
     },
     solo: {
       structureId: TEAM_STRUCTURE_IDS.solo,
       name: "Solo",
-      description: "A single agent working independently, with optional ephemeral architect and optional ephemeral uiux-engineer roles",
-      roles: ["solo", "architect", "uiux-engineer"],
+      description: "A single agent working independently, with optional ephemeral architect, triage, and uiux-engineer roles",
+      roles: getBuiltinRolesForTeam("solo"),
       entryPoint: "solo"
     }
   };
@@ -107812,6 +107954,7 @@ function getUiuxEngineerRequirements() {
 - Define component hierarchy and ownership, props/state/events, data boundaries, and interaction behavior.
 - Choose concrete existing ShadCN components with the Base UI backend and lucide-react/react-icons conventions; do not write "use an appropriate component."
 - Specify Tailwind utility classes or semantic theme-token classes for layout, spacing, sizing, typography, states, responsive behavior, and dark mode.
+- Provide the target HTML markup with exact class attributes and any required CSS/styles in the handoff.
 - Specify responsive breakpoints/layout behavior, visual feedback, destructive-action safeguards, exact files/components, and the UI/integration test plan.
 - Do not propose or require web accessibility implementation work unless the user explicitly requests it.`;
 }
@@ -107875,8 +108018,8 @@ ${getFileReferenceGuidanceComment()}
 **Change:** <precise add/modify/remove responsibility and why>
 
 \`\`\`text
-// Component hierarchy, props/state/events, test structure, or exact
-// Tailwind/theme-token classes. Enough detail that implementation requires no invention.
+// Target HTML markup, exact class attributes, and required CSS/styles.
+// Include component hierarchy and props/state/events needed for implementation.
 \`\`\`
 
 <add one block per file; do not collapse multiple files into a directory or vague layer>
@@ -108100,7 +108243,7 @@ function getPlannerToBuilderHandoffTemplate() {
 
 ${getDelegationBriefIntro()}
 
-**Division of labor:** You (planner) own architecture and API shape. The builder implements exactly what you specify and does not redesign or invent alternatives unless blocked.
+**Division of labor:** You (planner) own architecture and API shape. The UI/UX engineer owns UI/UX design. Include its target markup, classes, and styles in UI implementation briefs; the builder implements the components.
 
 **Detail bar:** Specify down to **every file** the builder will create or modify (full repo paths). Include code snippets — types, signatures, stubs, or target implementations — until a competent builder **cannot misinterpret** what to write. Vague layers ("update the backend", "fix the component") are not acceptable.
 
@@ -108476,6 +108619,12 @@ var init_uiux_engineer = __esm(() => {
   };
 });
 
+// ../shared/src/domain/chatroom-role.ts
+var CHATROOM_ROLE_USER = "user";
+var init_chatroom_role = __esm(() => {
+  init_agent_role();
+});
+
 // ../../services/backend/prompts/cli/handoff-templates/contracts.ts
 function validateRoleHandoffContracts(contracts) {
   const byRole = new Map;
@@ -108503,6 +108652,97 @@ function validateRoleHandoffContracts(contracts) {
     }
   }
 }
+function validateBuiltinOwners(teamName, expectedRoles, contracts) {
+  const actualRoles = new Set;
+  const byRole = new Map;
+  for (const contract of contracts) {
+    const normalizedOwner = contract.role.trim().toLowerCase();
+    if (!normalizedOwner || contract.role !== normalizedOwner) {
+      throw new Error(`${teamName} handoff owner "${contract.role}" is not canonical`);
+    }
+    if (actualRoles.has(normalizedOwner)) {
+      throw new Error(`${teamName} has duplicate handoff contract owner "${contract.role}"`);
+    }
+    if (!expectedRoles.has(normalizedOwner)) {
+      throw new Error(`${teamName} has unexpected handoff contract role "${contract.role}"`);
+    }
+    actualRoles.add(normalizedOwner);
+    byRole.set(normalizedOwner, contract);
+  }
+  for (const role of expectedRoles) {
+    if (!actualRoles.has(role)) {
+      throw new Error(`${teamName} is missing handoff contract for role "${role}"`);
+    }
+  }
+  return byRole;
+}
+function validateReferenceTargets(teamName, owner, label, targets, allowedTargets) {
+  const seen = new Set;
+  for (const target of targets) {
+    const normalizedTarget = target.trim().toLowerCase();
+    if (target !== normalizedTarget || !allowedTargets.has(normalizedTarget)) {
+      throw new Error(`${teamName} role "${owner}" has invalid ${label} target "${target}"`);
+    }
+    if (seen.has(normalizedTarget)) {
+      throw new Error(`${teamName} role "${owner}" has duplicate ${label} target "${target}"`);
+    }
+    seen.add(normalizedTarget);
+  }
+}
+function validateBuiltinReferences(teamName, allowedTargets, contracts) {
+  for (const contract of contracts) {
+    const owner = contract.role;
+    validateReferenceTargets(teamName, owner, "receivesFrom", contract.receivesFrom, allowedTargets);
+    validateReferenceTargets(teamName, owner, "returnsTo", contract.returnsTo, allowedTargets);
+    const outboundTargets = Object.keys(contract.outboundTemplates);
+    if (outboundTargets.length === 0) {
+      throw new Error(`${teamName} role "${owner}" must have an outbound handoff capability`);
+    }
+    const returnsTo = new Set(contract.returnsTo);
+    const outbound = new Set(outboundTargets);
+    validateReferenceTargets(teamName, owner, "outbound", outboundTargets, allowedTargets);
+    for (const target of outboundTargets) {
+      if (typeof contract.outboundTemplates[target] !== "function") {
+        throw new Error(`${teamName} role "${owner}" has no outbound getter for target "${target}"`);
+      }
+    }
+    if (returnsTo.size !== outbound.size || [...returnsTo].some((target) => !outbound.has(target))) {
+      throw new Error(`${teamName} role "${owner}" returnsTo targets must exactly match outbound targets`);
+    }
+  }
+}
+function validateBuiltinReciprocity(teamName, byRole, contracts) {
+  for (const contract of contracts) {
+    const owner = contract.role;
+    for (const receivedFrom of contract.receivesFrom) {
+      if (receivedFrom === CHATROOM_ROLE_USER)
+        continue;
+      const source = byRole.get(receivedFrom);
+      if (!source?.outboundTemplates[owner]) {
+        throw new Error(`${teamName} role "${owner}" receives from "${receivedFrom}" without a reverse outbound edge`);
+      }
+    }
+  }
+  try {
+    validateRoleHandoffContracts(contracts);
+  } catch (error51) {
+    const contextualError = new Error(`${teamName}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    Object.defineProperty(contextualError, "cause", { value: error51, configurable: true });
+    throw contextualError;
+  }
+}
+function validateBuiltinTeamRoleHandoffContracts(teamId, contracts) {
+  const teamName = TEAM_PRESETS[teamId].name;
+  const expectedRoles = new Set(TEAM_PRESETS[teamId].roles);
+  const byRole = validateBuiltinOwners(teamName, expectedRoles, contracts);
+  const allowedTargets = new Set([...expectedRoles, CHATROOM_ROLE_USER]);
+  validateBuiltinReferences(teamName, allowedTargets, contracts);
+  validateBuiltinReciprocity(teamName, byRole, contracts);
+}
+var init_contracts = __esm(() => {
+  init_chatroom_role();
+  init_team_presets();
+});
 
 // ../../services/backend/prompts/teams/duo/handoff-templates/index.ts
 function listDuoRoleHandoffContracts() {
@@ -108515,22 +108755,24 @@ function getDuoHandoffTemplate(query) {
   const getter = contract?.outboundTemplates[toRole];
   return getter?.(query) ?? null;
 }
-var DUO_ROLE_HANDOFF_CONTRACTS, validatedDuoRoleHandoffContracts;
+var DUO_ROLE_HANDOFF_CATALOG, DUO_ROLE_HANDOFF_CONTRACTS, validatedDuoRoleHandoffContracts;
 var init_handoff_templates = __esm(() => {
   init_architect();
   init_builder();
   init_planner();
   init_triage();
   init_uiux_engineer();
-  DUO_ROLE_HANDOFF_CONTRACTS = [
-    duoPlannerHandoffContract,
-    duoBuilderHandoffContract,
-    duoArchitectHandoffContract,
-    duoUiuxEngineerHandoffContract,
-    duoTriageHandoffContract
-  ];
+  init_contracts();
+  DUO_ROLE_HANDOFF_CATALOG = {
+    planner: duoPlannerHandoffContract,
+    builder: duoBuilderHandoffContract,
+    architect: duoArchitectHandoffContract,
+    "uiux-engineer": duoUiuxEngineerHandoffContract,
+    triage: duoTriageHandoffContract
+  };
+  DUO_ROLE_HANDOFF_CONTRACTS = Object.values(DUO_ROLE_HANDOFF_CATALOG);
   validatedDuoRoleHandoffContracts = (() => {
-    validateRoleHandoffContracts(DUO_ROLE_HANDOFF_CONTRACTS);
+    validateBuiltinTeamRoleHandoffContracts("duo", DUO_ROLE_HANDOFF_CONTRACTS);
     return DUO_ROLE_HANDOFF_CONTRACTS;
   })();
 });
@@ -108627,20 +108869,22 @@ function getSoloHandoffTemplate(query) {
   const getter = contract?.outboundTemplates[toRole];
   return getter?.(query) ?? null;
 }
-var SOLO_ROLE_HANDOFF_CONTRACTS, validatedSoloRoleHandoffContracts;
+var SOLO_ROLE_HANDOFF_CATALOG, SOLO_ROLE_HANDOFF_CONTRACTS, validatedSoloRoleHandoffContracts;
 var init_handoff_templates2 = __esm(() => {
   init_architect2();
   init_solo();
   init_triage2();
   init_uiux_engineer2();
-  SOLO_ROLE_HANDOFF_CONTRACTS = [
-    soloHandoffContract,
-    soloArchitectHandoffContract,
-    soloUiuxEngineerHandoffContract,
-    soloTriageHandoffContract
-  ];
+  init_contracts();
+  SOLO_ROLE_HANDOFF_CATALOG = {
+    solo: soloHandoffContract,
+    architect: soloArchitectHandoffContract,
+    "uiux-engineer": soloUiuxEngineerHandoffContract,
+    triage: soloTriageHandoffContract
+  };
+  SOLO_ROLE_HANDOFF_CONTRACTS = Object.values(SOLO_ROLE_HANDOFF_CATALOG);
   validatedSoloRoleHandoffContracts = (() => {
-    validateRoleHandoffContracts(SOLO_ROLE_HANDOFF_CONTRACTS);
+    validateBuiltinTeamRoleHandoffContracts("solo", SOLO_ROLE_HANDOFF_CONTRACTS);
     return SOLO_ROLE_HANDOFF_CONTRACTS;
   })();
 });
@@ -108665,7 +108909,7 @@ function listHandoffTemplates(query) {
   const templates = [];
   for (const toRole of Object.keys(contract.outboundTemplates).sort()) {
     const getter = contract.outboundTemplates[toRole];
-    const template = getter({
+    const template = getter?.({
       fromRole: contract.role,
       toRole,
       teamId,
@@ -109141,7 +109385,7 @@ var init_uiux_engineer3 = __esm(() => {
   init_sections();
   UIUX_ENGINEER_GUIDANCE = `## UI/UX Engineer Operating Model
 
-You are the UI/UX engineer responsible for producing one complete interface and experience design for the request. You are advisory only: do not implement code, edit files, or act as the builder.
+You are the UI/UX engineer responsible for UI/UX decisions and for producing one complete interface and experience design for the request. Provide the target markup, classes, and styles in your handoff. Do not implement code, edit files, or act as the builder.
 
 ${"{SESSION_CONTINUITY}"}
 
@@ -109216,8 +109460,112 @@ var init_role_guidance = __esm(() => {
 });
 
 // ../../services/backend/prompts/templates.ts
+var BUILTIN_ROLE_TEMPLATES, CUSTOM_ROLE_TEMPLATES, ROLE_TEMPLATES;
 var init_templates = __esm(() => {
   init_agent_role();
+  BUILTIN_ROLE_TEMPLATES = {
+    builder: {
+      role: "builder",
+      title: "Builder",
+      description: "You are the implementer responsible for writing code and building solutions.",
+      responsibilities: [
+        "Implement solutions based on requirements",
+        "Write clean, maintainable, well-documented code",
+        "Follow established patterns and best practices",
+        "Handle edge cases and error scenarios",
+        "Provide clear summaries of what was built"
+      ],
+      defaultHandoffTarget: "planner"
+    },
+    planner: {
+      role: "planner",
+      title: "Planner",
+      description: "You are the team coordinator responsible for user communication, task decomposition, and team management.",
+      responsibilities: [
+        "Communicate with the user as the single point of contact",
+        "Decompose complex tasks into actionable work items",
+        "Delegate work to available team members",
+        "Review completed work against user requirements",
+        "Manage the backlog and prioritize tasks",
+        "Hand back work for rework if requirements are not met"
+      ],
+      defaultHandoffTarget: "builder"
+    },
+    architect: {
+      role: "architect",
+      title: "Architect",
+      description: "You are the architect responsible for producing one complete implementation design for the request; you are not an implementer.",
+      responsibilities: [
+        "Recover the authoritative user request and relevant history",
+        "Inspect repository patterns and identify the coding change surface",
+        "Design module boundaries, APIs, schemas, queries, invariants, and failure handling",
+        "Specify the implementation and verification sequence at code granularity",
+        "Hand one evidence-backed design to the planner for implementation"
+      ],
+      defaultHandoffTarget: "planner"
+    },
+    triage: {
+      role: "triage",
+      title: "Triage Agent",
+      description: "You are the triage agent responsible for thoroughly investigating reported bugs and returning an evidence-backed diagnosis; you do not implement fixes.",
+      responsibilities: [
+        "Recover the reported symptoms and expected behavior from the authoritative request and relevant history",
+        "Trace the relevant code and state flow to identify a root cause, citing concrete repository evidence",
+        "Attempt to reproduce the issue with the smallest focused automated test and report the result honestly",
+        "Recommend the smallest immediate fix without implementing it",
+        "Report systemic design risks separately from the immediate fix",
+        "Hand the complete investigation report to the configured entry point"
+      ],
+      defaultHandoffTarget: "planner"
+    },
+    "uiux-engineer": {
+      role: "uiux-engineer",
+      title: "UI/UX Engineer",
+      description: "You are the UI/UX engineer responsible for producing one complete interface and experience design for the request; you are not an implementer.",
+      responsibilities: [
+        "Recover the authoritative user request and relevant history",
+        "Inspect existing UI patterns, components, tokens, and interaction conventions",
+        "Design complete user flows including loading, empty, error, and success states",
+        "Specify responsive layout, state ownership, and UI tests; include web accessibility implementation only when explicitly requested by the user",
+        "Hand one evidence-backed design to the planner for implementation"
+      ],
+      defaultHandoffTarget: "planner"
+    },
+    solo: {
+      role: "solo",
+      title: "Solo",
+      description: "You are the autonomous agent responsible for both planning and executing tasks independently.",
+      responsibilities: [
+        "Communicate directly with the user as the single point of contact",
+        "Decompose complex tasks into actionable work items",
+        "Implement solutions: write clean, maintainable code",
+        "Follow established patterns and best practices",
+        "Handle edge cases and error scenarios",
+        "Review and validate your own work for quality",
+        "Deliver completed results to the user"
+      ],
+      defaultHandoffTarget: "user"
+    }
+  };
+  CUSTOM_ROLE_TEMPLATES = {
+    tester: {
+      role: "tester",
+      title: "Tester",
+      description: "You are the QA role responsible for testing and validation.",
+      responsibilities: [
+        "Write and execute test cases",
+        "Verify functionality works as expected",
+        "Test edge cases and error handling",
+        "Report bugs and issues clearly",
+        "Confirm quality standards are met"
+      ],
+      defaultHandoffTarget: "user"
+    }
+  };
+  ROLE_TEMPLATES = {
+    ...BUILTIN_ROLE_TEMPLATES,
+    ...CUSTOM_ROLE_TEMPLATES
+  };
 });
 
 // ../../services/backend/prompts/sections/role-identity.ts
@@ -136733,4 +137081,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=AE2A4CFFF5FE9DDE64756E2164756E21
+//# debugId=23917805A998950464756E2164756E21