chatroom-cli 1.122.1 → 1.122.2

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"
     }
   };
@@ -108476,6 +108618,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 +108651,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 +108754,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 +108868,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 +108908,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,
@@ -109216,8 +109459,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 +137080,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=AE2A4CFFF5FE9DDE64756E2164756E21
+//# debugId=1F68354F72E2582064756E2164756E21