iriai-build 0.1.0

package/lib/prompt-builder.js

@@ -0,0 +1,565 @@
+// prompt-builder.js — All prompt templates ported from bash heredocs to JS.
+// Source mappings:
+//   buildOperatorPrompt     ← run-operator.sh L133-160
+//   buildRolePrompt         ← run-role.sh L232-255
+//   buildOrchestratorPrompt ← run-team.sh L293-322
+//   buildPlanningRolePrompt ← run-planning-role.sh L158-198
+//   buildFeatureLeadInitPrompt   ← run-feature-lead.sh L682-701
+//   buildFeatureLeadTriggerPrompt ← run-feature-lead.sh L920-1016
+
+import { IRIAI_TEAM_DIR, IMPL_BASE } from "./constants.js";
+
+// ─── Operator ────────────────────────────────────────────────────────────────
+
+export function buildOperatorPrompt({ featureName, operatorDir, flDir, featureDir, history, userMessage }) {
+  return `You are the Operator for feature '${featureName}'.
+
+## Your Signal Directory
+OPERATOR_DIR=${operatorDir}
+
+## Feature Lead Directory
+FL_DIR=${flDir}
+
+## Feature Signal Tree Root
+FEATURE_DIR=${featureDir}
+
+## Implementation Signal Base
+IMPL_SIGNAL_BASE=${IMPL_BASE}
+
+## iriai-team Directory
+IRIAI_TEAM_DIR=${IRIAI_TEAM_DIR}
+
+## Conversation History
+${history || "(no prior conversation)"}
+
+## Current Message
+${userMessage}
+
+---
+
+Read your CLAUDE.md at ${operatorDir}/CLAUDE.md for your full role definition and capabilities.
+
+Handle the user's current message above. You have the conversation history for context — refer to it to maintain continuity. Write your response to ${operatorDir}/.agent-response and exit.
+
+To include file attachments (screenshots, GIFs, logs) in your Slack response, embed markers in your .agent-response text:
+  [gif:/absolute/path/to/file.gif]
+The bridge will upload each file as a Slack attachment in the same thread.`;
+}
+
+// ─── Role Agent ──────────────────────────────────────────────────────────────
+
+export function buildRolePrompt({ role, signalDir, task, recoveryContext }) {
+  let recovery = "";
+  if (recoveryContext?.type === "handover") {
+    recovery = `
+---
+CONTEXT HANDOVER: Your previous session ran low on context and wrote a structured handover.
+Read the handover below carefully — it contains your completed work, current state, and remaining tasks.
+Pick up EXACTLY where the previous session left off. Do NOT redo completed work.
+---
+
+HANDOVER FROM PREVIOUS SESSION:
+${recoveryContext.content}
+
+---
+END OF HANDOVER
+`;
+  } else if (recoveryContext?.type === "crash") {
+    recovery = `
+---
+RECOVERY (retry ${recoveryContext.retryCount}): Your previous session crashed, possibly from context exhaustion.
+Before starting work, check the current state of any files you would modify — some changes
+may already be done. Use git status and git diff to see what has changed. Do NOT redo completed
+work. Pick up from where the previous session left off.
+---
+
+`;
+  }
+
+  return `You are the ${role}. Read your instructions at ${signalDir}/CLAUDE.md FIRST before starting any work.
+${recovery}
+Your task is below. If it has YAML frontmatter (between --- delimiters), read ALL fields before starting work. Pay special attention to:
+- scope.modify: ONLY modify these files
+- acceptance.user_criteria: this defines 'done'
+- counterexamples: do NOT do these things
+- context_files: read these FIRST
+
+${task}
+
+---
+IMPORTANT — OUTPUT AND COMPLETION:
+1. When your work is complete, write a summary to your output file. Use structured YAML frontmatter if your CLAUDE.md specifies it:
+\`\`\`bash
+cat > ${signalDir}/.output << 'OUTPUT_EOF'
+<your structured output here — see CLAUDE.md for format>
+OUTPUT_EOF
+\`\`\`
+2. Do NOT write to HANDOVER.md — the orchestrator will consolidate all role outputs.
+3. Then signal completion as your very last action:
+\`\`\`bash
+echo DONE > ${signalDir}/.done
+\`\`\`
+Do NOT forget the .done signal. The orchestrator is waiting for it.`;
+}
+
+// ─── Team Orchestrator ───────────────────────────────────────────────────────
+
+export function buildOrchestratorPrompt({ teamDir, orchDir, task, recoveryContext }) {
+  let recovery = "";
+  if (recoveryContext) {
+    recovery = `
+---
+RECOVERY (retry ${recoveryContext.retryCount}): Your previous session crashed, possibly from context exhaustion.
+Before re-dispatching roles, check the current state:
+- Read ${teamDir}/HANDOVER.md to understand what roles have already completed
+- Read ${teamDir}/STEP-SUMMARY.md if it exists for step progress
+- Check each role's signal dir for .done files — roles that already finished do NOT need re-dispatch
+- Use git status and git diff in your worktree to see what code changes exist
+Do NOT redo completed work. Only dispatch roles for remaining uncompleted steps.
+---
+`;
+  }
+
+  return `You are a Team Orchestrator. Read your instructions at ${orchDir}/CLAUDE.md FIRST.
+
+CRITICAL: You are a DISPATCHER. You must NEVER write code, edit source files, run tests, or fix bugs yourself. ALL implementation work is done by your role agents via .task files. If something needs fixing, re-dispatch the appropriate role — do NOT do it yourself.
+
+Read your team config at ${teamDir}/.team-config to see which roles are available.
+Read ${teamDir}/GATE-CONTEXT.md for your team's assignment and cross-team context.
+${recovery}
+CRITICAL — SIGNAL FILE PATHS: Your signal directory is ${teamDir} (NOT your working directory).
+Use these ABSOLUTE paths for ALL signal files:
+  - Dispatch to role:       ${teamDir}/roles/<role>/.task
+  - Monitor role completion: ${teamDir}/roles/<role>/.done
+  - Read role output:        ${teamDir}/roles/<role>/.output
+  - Gate ready signal:       ${orchDir}/.gate-ready
+  - Question escalation:     ${orchDir}/.question
+  - Receive answer:          ${orchDir}/.answer
+  - HANDOVER.md:             ${teamDir}/HANDOVER.md
+  - STEP-SUMMARY.md:         ${teamDir}/STEP-SUMMARY.md
+Do NOT use relative paths for signal files — your working directory is a worktree, not the signal directory.
+
+YOUR ASSIGNMENT:
+${task}
+
+---
+IMPORTANT — GATE COMPLETION SIGNAL: When ALL steps are complete for this gate and your team's code reviewer has approved, you MUST run this exact command:
+\`\`\`bash
+echo READY > ${orchDir}/.gate-ready
+\`\`\`
+Do NOT proceed beyond this gate's assigned work. The Feature Lead will dispatch your next gate.`;
+}
+
+// ─── Planning Role ───────────────────────────────────────────────────────────
+
+export function buildPlanningRolePrompt({ task, signalDir, featureSlug }) {
+  return `${task}
+
+---
+
+SLACK MODE ACTIVE: All user interaction happens via signal files in your working directory.
+You are NOT in an interactive terminal. The user is on Slack.
+
+COMMUNICATION PROTOCOL:
+1. To send a message to the user: write your message to .agent-response
+   echo "your message here" > .agent-response
+   The Slack bridge will post it to the user's thread and delete the file.
+
+2. To receive a message from the user: poll for .user-message
+   while [ ! -f .user-message ]; do sleep 5; done
+   Read the content, then delete it:
+   MSG=$(cat .user-message) && rm -f .user-message
+
+3. For questions needing user input: write to .agent-response with your question.
+   Include numbered options and bold the question. Keep messages under 300 words.
+   Then poll for .user-message for the user's reply.
+
+4. When you encounter a clarifying question from another agent or need to raise
+   a question yourself, write the FULL question verbatim to .agent-response.
+   Include: which role is asking, what phase/task it concerns, the options considered,
+   and any recommendation. The bridge will post it to Slack with your role attribution.
+
+5. Format for mobile: the user reads on their phone. Under 300 words per message.
+   Use numbered options for choices. Bold key questions.
+
+IMPORTANT: After each .agent-response write, wait 2 seconds before polling for
+.user-message to give the bridge time to pick up and delete your response file.
+
+Your signal directory: ${signalDir}
+Feature: ${featureSlug || "unknown"}
+
+When done, signal completion as usual:
+echo "DONE" > .done
+echo "<summary>" > .output`;
+}
+
+// ─── Feature Lead: Shared Prompt Fragments ───────────────────────────────────
+
+function buildSlackCommInstructions(featureLeadDir) {
+  return `
+## SLACK MODE ACTIVE
+
+All user interaction happens via signal files. You are NOT in an interactive terminal. The user is on Slack (mobile).
+
+COMMUNICATION PROTOCOL:
+1. To send a message to the user: write to ${featureLeadDir}/.agent-response
+   \`\`\`bash
+   cat > ${featureLeadDir}/.agent-response << 'MSG_EOF'
+   Your message here
+   MSG_EOF
+   \`\`\`
+   The Slack bridge posts it to #impl-<slug> and deletes the file.
+
+2. To receive a message from the user: poll for .user-message
+   \`\`\`bash
+   while [ ! -f ${featureLeadDir}/.user-message ]; do sleep 5; done
+   MSG=$(cat ${featureLeadDir}/.user-message) && rm -f ${featureLeadDir}/.user-message
+   \`\`\`
+
+3. For questions needing user input: write to .agent-response with your question.
+   Include numbered options and bold the question. Then poll for .user-message.
+
+4. Gate approval: write gate evidence to .agent-response. The bridge posts it with
+   approval reactions. The user's response arrives as .user-message.
+
+5. Format for mobile: under 300 words per message. Numbered options. Bold key questions.
+
+6. After writing .agent-response, wait 2 seconds before polling for .user-message.
+
+7. On startup, introduce yourself by writing to .agent-response:
+   'Feature Lead online for <feature>. Reading plan and preparing dispatch...'
+`;
+}
+
+function buildMonitorInstructions(numTeams, teamSignalBase, featureLeadDir, featureReviewDir) {
+  return `
+## Monitor Teams Until All Are Gate-Ready
+
+After dispatching, you MUST stay active and monitor teams continuously. Poll every 75 seconds:
+\`\`\`bash
+# Poll loop — run this repeatedly
+for i in $(seq 1 ${numTeams}); do
+  orch="${teamSignalBase}/team-$i/orchestrator"
+  [ -f "$orch/.gate-ready" ] && echo "READY: Team $i"
+  [ -f "$orch/.question" ] && echo "QUESTION: Team $i"
+  [ -f "$orch/.crashed" ] && echo "CRASHED: Team $i"
+done
+# Also check for user messages from Slack
+if [ -f "${featureLeadDir}/.user-message" ]; then
+  echo "USER MESSAGE: $(cat ${featureLeadDir}/.user-message)"
+  rm -f "${featureLeadDir}/.user-message"
+fi
+\`\`\`
+
+While monitoring:
+- When a team signals .gate-ready: narrate it to the user using the GATE-READY format from your CLAUDE.md. Read the team's HANDOVER.md for a summary.
+- When a team has a .question: handle it per the Question Handling section (answer or escalate to user)
+- When a team .crashed: handle per Failure Recovery (read HANDOVER.md, re-dispatch with recovery .task)
+- When a USER MESSAGE appears: read it, respond via .agent-response (status update, answer question, etc.), then continue monitoring
+- Keep polling until ALL ${numTeams} teams have signaled .gate-ready
+- Do NOT exit or signal .phase-done until all teams are ready
+
+### Health Monitor
+If a team has been running for > 20 minutes with no new .done signals from roles, or all roles
+show .done but no .gate-ready appears within 10 minutes, dispatch the health-monitor:
+\`\`\`bash
+cat > ${featureReviewDir}/health-monitor/.task << 'TASK_EOF'
+Run a full health check across all teams.
+Specific concern: [describe what you observe]
+Teams to check: [all / specific team numbers]
+TASK_EOF
+\`\`\`
+Then poll for feature-review/health-monitor/.done, read its .output, and act on recommendations.`;
+}
+
+function buildGateReviewInstructions(featureLeadDir, featureReviewDir) {
+  return `
+## Gate Review (once all teams are gate-ready)
+
+1. Read each team's HANDOVER.md and STEP-SUMMARY.md for results
+2. Push team branches and create PRs (team branch → integration branch) per repo using gh CLI
+3. Dispatch feature-level review agents by writing .task files (these agents are ALREADY RUNNING
+   in their own Zellij panes — do NOT spawn subagents, do NOT use the Task tool, just write the file):
+   \`\`\`bash
+   # If preview-env.json exists, include it in integration tester task
+   PREVIEW_ENV=""
+   if [ -f "${featureLeadDir}/preview-env.json" ]; then
+     PREVIEW_ENV="Preview environment: ${featureLeadDir}/preview-env.json"
+   fi
+   cat > ${featureReviewDir}/integration-tester/.task << TASK_EOF
+   <your review task here>
+   $PREVIEW_ENV
+   TASK_EOF
+   cat > ${featureReviewDir}/code-reviewer/.task << 'TASK_EOF'
+   <your review task here>
+   TASK_EOF
+   cat > ${featureReviewDir}/security-auditor/.task << 'TASK_EOF'
+   <your review task here>
+   TASK_EOF
+   \`\`\`
+4. Wait for all feature-review agents to complete (.done files) — poll every 75s:
+   \`\`\`bash
+   while [ ! -f ${featureReviewDir}/integration-tester/.done ] || \\
+         [ ! -f ${featureReviewDir}/code-reviewer/.done ] || \\
+         [ ! -f ${featureReviewDir}/security-auditor/.done ]; do
+     sleep 75
+   done
+   \`\`\`
+5. Read their .output files and synthesize results
+6. Present a GATE SUMMARY to the user with PR links and review results
+7. WAIT for the user to approve or reject the gate
+8. If approved: merge PRs, tag gate checkpoint, update worktrees, clear .gate-ready files
+9. Update FEATURE-STATUS.md and DASHBOARD.md with gate results
+10. If this is the FINAL gate: create PRs to main, generate RETROSPECTIVE.md, cleanup, then signal:
+    \`\`\`bash
+    echo COMPLETE > ${featureLeadDir}/.feature-complete
+    \`\`\`
+
+IMPORTANT: Do NOT dispatch the next gate yourself. After approval, just merge, clear signals,
+update status files, and signal phase-done. A new session will handle the next gate dispatch.
+
+When the gate is approved and merged (or final gate complete):
+\`\`\`bash
+echo GATE_HANDLED > ${featureLeadDir}/.phase-done
+\`\`\``;
+}
+
+function buildContextManagementInstructions(featureLeadDir, dashboardLog) {
+  return `
+## Context Management (MANDATORY)
+
+You run inside a finite context window with NO automatic compaction. If you exhaust it, you crash —
+and ANY state held only in your conversation memory is PERMANENTLY LOST. You must proactively manage
+your context to ensure you NEVER crash before checkpointing.
+
+### Self-Monitoring
+
+Track your context usage by counting major operations. Each of these costs significant context:
+- Reading a file (especially large files like implementation plans or HANDOVER.md)
+- Writing a task file, GATE-CONTEXT.md, or status update
+- Running a bash command and processing its output
+- Each polling iteration that produces output
+
+**Thresholds:**
+- After ~40 major tool uses in a single session → strongly consider a context refresh
+- After ~60 major tool uses → you MUST refresh at the next natural boundary
+- If you feel the conversation is getting long or you are losing track of details → refresh immediately
+
+### When to Refresh
+
+Trigger a context refresh at any natural boundary:
+- After dispatching a gate (all .task files written, status updated)
+- After completing gate review and getting user approval (after merge + cleanup)
+- After handling 3+ questions or crashes in one session
+- After a long monitoring stretch with many poll cycles
+- Whenever you sense your context is getting heavy — trust your judgment
+
+### Pre-Refresh Checklist (MANDATORY — NEVER SKIP)
+
+Before writing the context refresh signal, you MUST update ALL of the following.
+Skipping any of these means permanent data loss:
+
+1. **FEATURE-STATUS.md** — Update with:
+   - Current phase and gate number
+   - All team statuses (which are ready, working, crashed)
+   - Decisions you made this session (question answers, contract changes)
+   - What you were doing when you decided to refresh
+   - What needs to happen next (explicit next steps for the fresh session)
+
+2. **DASHBOARD.md** — Rebuild with latest team status, gate progress, open questions
+
+3. **.dashboard-log** — Append a refresh event:
+   \`\`\`bash
+   echo "$(date +%H:%M:%S) | feature-lead | context-refresh" >> ${dashboardLog}
+   \`\`\`
+
+4. **GATE-CONTEXT.md (all teams)** — Complete or note which teams still need context
+
+5. **Cross-team contracts** — Record any established/modified contracts in FEATURE-STATUS.md
+
+6. **Open questions** — Verify .answer files written, log decision rationale
+
+### How to Refresh
+
+After completing the full checklist above:
+\`\`\`bash
+echo REFRESH > ${featureLeadDir}/.context-refresh
+\`\`\`
+
+### Emergency Refresh
+
+If context is critically low:
+1. Write MINIMAL but complete FEATURE-STATUS.md update
+2. Signal immediately:
+   \`\`\`bash
+   echo REFRESH > ${featureLeadDir}/.context-refresh
+   \`\`\``;
+}
+
+// ─── Feature Lead: Init Prompt ───────────────────────────────────────────────
+
+export function buildFeatureLeadInitPrompt({
+  featureName, numTeams, teamType, teamSignalBase,
+  planReadInstruction, featureLeadDir, featureReviewDir, dashboardLog,
+}) {
+  const monitor = buildMonitorInstructions(numTeams, teamSignalBase, featureLeadDir, featureReviewDir);
+  const gateReview = buildGateReviewInstructions(featureLeadDir, featureReviewDir);
+  const contextMgmt = buildContextManagementInstructions(featureLeadDir, dashboardLog);
+  const slackComm = buildSlackCommInstructions(featureLeadDir);
+
+  return `You are the Feature Lead for '${featureName}' with ${numTeams} teams (type: ${teamType}).
+
+Read your instructions at ~/src/iriai/iriai-team/roles-v2/feature-lead/CLAUDE.md.
+Read the feature status at ~/src/iriai/iriai-team/FEATURE-STATUS.md.
+${planReadInstruction}
+
+## Dispatch Gate 1
+
+1. Read and understand the full implementation plan
+2. Identify the gate boundaries in the plan
+3. Partition Gate 1 work across ${numTeams} teams
+4. Write GATE-CONTEXT.md for each team (at ${teamSignalBase}/team-N/GATE-CONTEXT.md)
+5. Write team manifests if not present (at ${teamSignalBase}/team-N/manifest.yaml)
+6. Dispatch to each team orchestrator by writing .task files (at ${teamSignalBase}/team-N/orchestrator/.task)
+7. Update FEATURE-STATUS.md with gate 1 status
+8. Update DASHBOARD.md
+${monitor}
+${gateReview}
+${contextMgmt}
+${slackComm}`;
+}
+
+// ─── Feature Lead: Refresh/Continue Prompt ───────────────────────────────────
+
+export function buildFeatureLeadRefreshPrompt({
+  featureName, numTeams, teamSignalBase,
+  planReadInstruction, featureLeadDir, featureReviewDir, dashboardLog,
+  gateEvidenceTs,
+}) {
+  const monitor = buildMonitorInstructions(numTeams, teamSignalBase, featureLeadDir, featureReviewDir);
+  const gateReview = buildGateReviewInstructions(featureLeadDir, featureReviewDir);
+  const contextMgmt = buildContextManagementInstructions(featureLeadDir, dashboardLog);
+  const slackComm = buildSlackCommInstructions(featureLeadDir);
+
+  const gateDedup = gateEvidenceTs
+    ? `\nIMPORTANT: Gate evidence was ALREADY posted to Slack at timestamp ${gateEvidenceTs}.\nDo NOT re-post gate evidence. You are waiting for the user's GATE APPROVED / GATE REJECTED response\nin the impl channel. Poll for .user-message, do not repost.\n`
+    : "";
+
+  return `You are the Feature Lead for '${featureName}' with ${numTeams} teams.
+
+Read your instructions at ~/src/iriai/iriai-team/roles-v2/feature-lead/CLAUDE.md.
+
+CONTEXT REFRESH: Your previous session requested a context refresh. All state has been
+persisted to disk. Read these files to restore your state:
+
+1. ~/src/iriai/iriai-team/FEATURE-STATUS.md — your persistent memory (source of truth)
+2. ~/src/iriai/iriai-team/DASHBOARD.md — current team status
+3. Each team's GATE-CONTEXT.md at ${teamSignalBase}/team-N/GATE-CONTEXT.md
+
+Check FEATURE-STATUS.md for 'what was in progress' and 'next steps' to understand
+exactly where to resume. Do not re-do completed work.
+${gateDedup}
+${planReadInstruction}
+${monitor}
+${gateReview}
+${contextMgmt}
+${slackComm}`;
+}
+
+// ─── Feature Lead: Trigger-Based Phase Prompt ────────────────────────────────
+
+export function buildFeatureLeadTriggerPrompt({
+  featureName, numTeams, trigger, teamSignalBase,
+  featureLeadDir, featureReviewDir, dashboardLog,
+  questionTeams, crashedTeams, recoveryContext,
+}) {
+  const monitor = buildMonitorInstructions(numTeams, teamSignalBase, featureLeadDir, featureReviewDir);
+  const gateReview = buildGateReviewInstructions(featureLeadDir, featureReviewDir);
+  const contextMgmt = buildContextManagementInstructions(featureLeadDir, dashboardLog);
+  const slackComm = buildSlackCommInstructions(featureLeadDir);
+
+  let base = `You are the Feature Lead for '${featureName}' with ${numTeams} teams.
+
+Read your instructions at ~/src/iriai/iriai-team/roles-v2/feature-lead/CLAUDE.md.
+Read the feature status at ~/src/iriai/iriai-team/FEATURE-STATUS.md.
+Read ~/src/iriai/iriai-team/DASHBOARD.md for current state.
+`;
+
+  if (recoveryContext) {
+    base = `RECOVERY: Your prior session crashed during this phase. Resume from where you left off.
+Read ~/src/iriai/iriai-team/FEATURE-STATUS.md for current state.
+Read ~/src/iriai/iriai-team/DASHBOARD.md for team status.
+
+${base}`;
+  }
+
+  switch (trigger) {
+    case "gate-ready":
+      base += `
+TRIGGER: All ${numTeams} teams have signaled .gate-ready.
+${gateReview}`;
+      break;
+
+    case "question":
+      base += `
+TRIGGER: Teams ${questionTeams.join(", ")} have questions that need resolution.
+
+You must:
+1. Read each questioning team's .question file at ${teamSignalBase}/team-N/orchestrator/.question
+2. Read FEATURE-STATUS.md for cross-team context
+3. If you can resolve the question with your cross-team knowledge:
+   - Write the answer to ${teamSignalBase}/team-N/orchestrator/.answer
+   - Remove the .question file
+4. If you cannot resolve it: surface it to the user and wait for their response
+   - Then write the user's answer to ${teamSignalBase}/team-N/orchestrator/.answer
+   - Remove the .question file
+5. Update FEATURE-STATUS.md and DASHBOARD.md
+
+After handling questions, continue monitoring teams:
+${monitor}
+${gateReview}`;
+      break;
+
+    case "crash":
+      base += `
+TRIGGER: Teams ${crashedTeams.join(", ")} have crashed orchestrators.
+
+You must:
+1. Read the crashed team's HANDOVER.md to understand progress
+2. Determine what work was completed and what remains
+3. Write a recovery .task to ${teamSignalBase}/team-N/orchestrator/.task that:
+   - References HANDOVER.md for completed work
+   - Assigns only the remaining work
+4. Remove the .crashed file (run-team.sh will detect the new .task)
+5. If recovery isn't possible, surface the issue to the user
+6. Update FEATURE-STATUS.md and DASHBOARD.md
+
+After handling crashes, continue monitoring teams:
+${monitor}
+${gateReview}`;
+      break;
+
+    case "idle-redispatch":
+      base += `
+TRIGGER: All ${numTeams} teams are idle — they have no active .task files.
+This typically happens after a session restart (launch.sh continue).
+
+## Re-dispatch Teams
+
+1. Read FEATURE-STATUS.md to understand the current gate and what was dispatched
+2. Read each team's GATE-CONTEXT.md and HANDOVER.md to understand their assignment and progress
+3. For each team, write a new .task file to ${teamSignalBase}/team-N/orchestrator/.task
+   - If the team has made progress (check HANDOVER.md), assign only remaining work
+   - If no progress, re-dispatch the full gate assignment from GATE-CONTEXT.md
+4. Update FEATURE-STATUS.md and DASHBOARD.md
+${monitor}
+${gateReview}`;
+      break;
+  }
+
+  base += `
+${contextMgmt}
+${slackComm}`;
+
+  return base;
+}