@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/cli/routines-command.ts

@@ -1,10 +1,12 @@
 import { createShellPathService } from '@/runtime/index.ts';
+import { formatAgentRecordOrigin, formatAgentRecordReviewState } from '../agent/record-labels.ts';
 import { discoverRoutines, type DiscoveredRoutineRecord } from '../agent/routine-discovery.ts';
-import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import { AgentRoutineRegistry, evaluateAgentRoutineReadiness, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import { buildAgentSkillRequirements, formatAgentSkillRequirement } from '../agent/skill-registry.ts';
 import {
   buildRoutineSchedulePreview,
-  promoteRoutineToDaemonSchedule,
-  resolveAgentDaemonConnection,
+  promoteRoutineToConnectedSchedule,
+  resolveAgentConnectedHostConnection,
 } from '../agent/routine-schedule-promotion.ts';
 import { parseRoutineSchedulePromotionArgs } from '../agent/routine-schedule-args.ts';
 import {
@@ -34,10 +36,26 @@ interface RoutinesCommandFailure {
   readonly error: string;
 }
 
+interface ParsedRoutineOptions {
+  readonly positionals: readonly string[];
+  readonly flags: ReadonlyMap<string, string>;
+  readonly yes: boolean;
+}
+
+const ROUTINE_CREATE_USAGE = 'Usage: goodvibes-agent routines create --name <name> --description <summary> --steps <steps> [--tags a,b] [--triggers a,b] [--requires-env A,B] [--requires-command gh,jq] [--enabled]';
+
 function jsonOrText(runtime: CliCommandRuntime, value: unknown, text: string): string {
   return runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(value, null, 2) : text;
 }
 
+function commandFailure(runtime: CliCommandRuntime, kind: string, error: string, exitCode: number): CliCommandOutput {
+  const failure: RoutinesCommandFailure = { ok: false, kind, error };
+  return {
+    output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : error,
+    exitCode,
+  };
+}
+
 function routineRegistry(runtime: CliCommandRuntime): AgentRoutineRegistry {
   return AgentRoutineRegistry.fromShellPaths(createShellPathService({
     workingDirectory: runtime.workingDirectory,
@@ -64,6 +82,47 @@ function splitList(value: string | undefined): readonly string[] {
   return value.split(',').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function parseRoutineOptions(args: readonly string[]): ParsedRoutineOptions {
+  const flags = new Map<string, string>();
+  const positionals: string[] = [];
+  let yes = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? '';
+    if (token === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      const next = args[index + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags.set(key, next);
+        index += 1;
+      } else {
+        flags.set(key, 'true');
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+  return { positionals, flags, yes };
+}
+
+function optionValue(options: ParsedRoutineOptions, key: string): string | undefined {
+  const value = options.flags.get(key)?.trim();
+  return value ? value : undefined;
+}
+
+function hasFlag(options: ParsedRoutineOptions, key: string): boolean {
+  return options.flags.get(key) === 'true';
+}
+
+function requiredOption(options: ParsedRoutineOptions, key: string): string {
+  const value = optionValue(options, key);
+  if (!value) throw new Error(`${ROUTINE_CREATE_USAGE}\nMissing --${key}.`);
+  return value;
+}
+
 function parseImportFlags(args: readonly string[]): {
   readonly name: string;
   readonly enabled: boolean;
@@ -88,15 +147,17 @@ function parseImportFlags(args: readonly string[]): {
 
 function summarizeRoutine(routine: AgentRoutineRecord): string {
   const enabled = routine.enabled ? 'enabled' : 'disabled';
-  const tags = routine.tags.length > 0 ? ` tags=${routine.tags.join(',')}` : '';
-  return `  ${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
+  const tags = routine.tags.length > 0 ? `  tags ${routine.tags.join(', ')}` : '';
+  const readiness = evaluateAgentRoutineReadiness(routine);
+  const ready = readiness.ready ? 'ready' : `needs ${readiness.missing.map(formatAgentSkillRequirement).join(',')}`;
+  return `  ${routine.id}  ${enabled}  ${formatAgentRecordReviewState(routine.reviewState)}  ${ready}  starts ${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
 }
 
 function summarizeDiscoveredRoutine(routine: DiscoveredRoutineRecord): string {
   const description = routine.description ? ` - ${routine.description}` : '';
   return [
     `  ${routine.name}  ${routine.origin}${description}`,
-    `    path: ${routine.path}`,
+    `    path ${routine.path}`,
   ].join('\n');
 }
 
@@ -136,35 +197,46 @@ function discoveredRoutineFrontmatterList(routine: DiscoveredRoutineRecord, key:
   return splitList(value);
 }
 
-function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[]): string {
+function discoveredRoutineFrontmatterAnyList(routine: DiscoveredRoutineRecord, keys: readonly string[]): readonly string[] {
+  for (const key of keys) {
+    const values = discoveredRoutineFrontmatterList(routine, key);
+    if (values.length > 0) return values;
+  }
+  return [];
+}
+
+function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[], emptyMessage?: string): string {
   if (routines.length === 0) {
     return [
       title,
-      '  No local Agent routines yet.',
-      '  Create routines inside the Agent TUI with /routines create, or create an Agent profile from a starter template.',
-    ].join('\n');
+      `  ${emptyMessage ?? 'No Agent-local routines yet.'}`,
+      emptyMessage ? '' : '  Open /agent routines in the TUI, or use goodvibes-agent routines create for scripted setup.',
+    ].filter(Boolean).join('\n');
   }
   return [
     `${title} (${routines.length})`,
-    `  store: ${path}`,
+    `  store ${path}`,
     ...routines.map(summarizeRoutine),
   ].join('\n');
 }
 
 function renderRoutine(routine: AgentRoutineRecord): string {
+  const readiness = evaluateAgentRoutineReadiness(routine);
   return [
     `Routine ${routine.name}`,
-    `  id: ${routine.id}`,
-    `  enabled: ${routine.enabled ? 'yes' : 'no'}`,
-    `  review: ${routine.reviewState}`,
-    `  source: ${routine.source}`,
-    `  provenance: ${routine.provenance}`,
-    `  tags: ${routine.tags.join(', ') || '(none)'}`,
-    `  triggers: ${routine.triggers.join(', ') || '(manual)'}`,
-    `  started: ${routine.startCount}${routine.lastStartedAt ? `; last ${routine.lastStartedAt}` : ''}`,
-    `  created: ${routine.createdAt}`,
-    `  updated: ${routine.updatedAt}`,
-    routine.staleReason ? `  stale reason: ${routine.staleReason}` : '',
+    `  id ${routine.id}`,
+    `  enabled ${routine.enabled ? 'yes' : 'no'}`,
+    `  readiness ${readiness.ready ? 'ready' : 'needs setup'}`,
+    `  requirements ${routine.requirements.map(formatAgentSkillRequirement).join(', ') || '(none)'}`,
+    readiness.missing.length > 0 ? `  missing ${readiness.missing.map(formatAgentSkillRequirement).join(', ')}` : '',
+    `  review ${formatAgentRecordReviewState(routine.reviewState)}`,
+    `  origin ${formatAgentRecordOrigin(routine.source, routine.provenance)}`,
+    `  tags ${routine.tags.join(', ') || '(none)'}`,
+    `  triggers ${routine.triggers.join(', ') || '(manual)'}`,
+    `  started ${routine.startCount}${routine.lastStartedAt ? `; last ${routine.lastStartedAt}` : ''}`,
+    `  created ${routine.createdAt}`,
+    `  updated ${routine.updatedAt}`,
+    routine.staleReason ? `  stale reason ${routine.staleReason}` : '',
     '',
     routine.description,
     '',
@@ -195,7 +267,7 @@ async function handleRoutinePromotion(runtime: CliCommandRuntime, args: readonly
     const failure: RoutinesCommandFailure = {
       ok: false,
       kind: 'routine_not_found',
-      error: `Unknown Agent routine: ${parsed.routineId ?? ''}`,
+      error: `Unknown Agent routine ${parsed.routineId ?? ''}`,
     };
     return {
       output: json ? JSON.stringify(failure, null, 2) : failure.error,
@@ -214,8 +286,8 @@ async function handleRoutinePromotion(runtime: CliCommandRuntime, args: readonly
       exitCode: 0,
     };
   }
-  const connection = resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory);
-  const result = await promoteRoutineToDaemonSchedule(connection, preview);
+  const connection = resolveAgentConnectedHostConnection(runtime.configManager, runtime.homeDirectory);
+  const result = await promoteRoutineToConnectedSchedule(connection, preview);
   const receipt = routineReceiptStore(runtime).append(connection, preview, result);
   if (!result.ok) {
     return {
@@ -235,15 +307,23 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
   const registry = routineRegistry(runtime);
   const snapshot = registry.snapshot();
   const normalized = sub.toLowerCase();
-  if (normalized === 'list' || normalized === 'enabled') {
-    const routines = normalized === 'enabled' ? snapshot.enabledRoutines : snapshot.routines;
+  if (normalized === 'list' || normalized === 'enabled' || normalized === 'attention' || normalized === 'needs-setup') {
+    const routines = normalized === 'enabled'
+      ? snapshot.enabledRoutines
+      : normalized === 'attention' || normalized === 'needs-setup'
+        ? snapshot.routines.filter((routine) => !evaluateAgentRoutineReadiness(routine).ready)
+        : snapshot.routines;
     const value: RoutinesCommandSuccess<{
       readonly path: string;
       readonly routines: readonly AgentRoutineRecord[];
       readonly enabledCount: number;
     }> = {
       ok: true,
-      kind: normalized === 'enabled' ? 'agent.routines.enabled' : 'agent.routines.list',
+      kind: normalized === 'enabled'
+        ? 'agent.routines.enabled'
+        : normalized === 'attention' || normalized === 'needs-setup'
+          ? 'agent.routines.attention'
+          : 'agent.routines.list',
       data: {
         path: snapshot.path,
         routines,
@@ -251,7 +331,16 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       },
     };
     return {
-      output: jsonOrText(runtime, value, renderRoutineList(normalized === 'enabled' ? 'Enabled Agent routines' : 'Agent routines', snapshot.path, routines)),
+      output: jsonOrText(runtime, value, renderRoutineList(
+        normalized === 'enabled'
+          ? 'Enabled Agent routines'
+          : normalized === 'attention' || normalized === 'needs-setup'
+            ? 'Agent routines needing setup'
+            : 'Agent routines',
+        snapshot.path,
+        routines,
+        normalized === 'attention' || normalized === 'needs-setup' ? 'No Agent-local routines need setup.' : undefined,
+      )),
       exitCode: 0,
     };
   }
@@ -285,7 +374,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       const failure: RoutinesCommandFailure = {
         ok: false,
         kind: 'routine_discovery_not_found',
-        error: `Unknown discovered Agent routine: ${parsed.name}\nRun goodvibes-agent routines discover to inspect available routine files.`,
+        error: `Unknown discovered Agent routine ${parsed.name}\nRun goodvibes-agent routines discover to inspect available routine files.`,
       };
       return {
         output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
@@ -301,12 +390,12 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       return {
         output: jsonOrText(runtime, value, [
           'Agent routine import preview',
-          `  name: ${discovered.name}`,
-          `  origin: ${discovered.origin}`,
-          `  path: ${discovered.path}`,
-          `  description: ${discovered.description || '(none)'}`,
-          `  steps characters: ${discovered.steps.length}`,
-          '  next: rerun with --yes to import into the Agent-local routine registry',
+          `  name ${discovered.name}`,
+          `  origin ${discovered.origin}`,
+          `  path ${discovered.path}`,
+          `  description ${discovered.description || '(none)'}`,
+          `  steps characters ${discovered.steps.length}`,
+          '  next rerun with --yes to import into the Agent-local routine registry',
         ].join('\n')),
         exitCode: 0,
       };
@@ -317,6 +406,10 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       steps: discovered.steps,
       tags: discoveredRoutineFrontmatterList(discovered, 'tags'),
       triggers: discoveredRoutineFrontmatterList(discovered, 'triggers'),
+      requirements: buildAgentSkillRequirements({
+        env: discoveredRoutineFrontmatterAnyList(discovered, ['requiresEnv', 'requires-env', 'requires_env']),
+        commands: discoveredRoutineFrontmatterAnyList(discovered, ['requiresCommands', 'requires-commands', 'requires_commands', 'commands']),
+      }),
       enabled: parsed.enabled,
       source: 'imported',
       provenance: `discovered:${discovered.origin}:${discovered.path}`,
@@ -327,10 +420,53 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       data: routine,
     };
     return {
-      output: jsonOrText(runtime, value, `Imported Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`),
+      output: jsonOrText(runtime, value, [
+        `Imported Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`,
+        `  name ${routine.name}`,
+        `  enabled ${routine.enabled ? 'yes' : 'no'}`,
+      ].join('\n')),
       exitCode: 0,
     };
   }
+  if (normalized === 'create') {
+    const options = parseRoutineOptions(rest);
+    try {
+      const routine = registry.create({
+        name: requiredOption(options, 'name'),
+        description: requiredOption(options, 'description'),
+        steps: optionValue(options, 'steps') ?? options.positionals.join(' ').trim(),
+        tags: splitList(optionValue(options, 'tags')),
+        triggers: splitList(optionValue(options, 'triggers')),
+        requirements: buildAgentSkillRequirements({
+          env: splitList(optionValue(options, 'requires-env')),
+          commands: splitList(optionValue(options, 'requires-command') ?? optionValue(options, 'requires-commands')),
+        }),
+        enabled: hasFlag(options, 'enabled'),
+        source: 'user',
+        provenance: 'cli',
+      });
+      const value: RoutinesCommandSuccess<AgentRoutineRecord> = {
+        ok: true,
+        kind: 'agent.routines.create',
+        data: routine,
+      };
+      return {
+        output: jsonOrText(runtime, value, [
+          `Created Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`,
+          `  name ${routine.name}`,
+          `  enabled ${routine.enabled ? 'yes' : 'no'}`,
+        ].join('\n')),
+        exitCode: 0,
+      };
+    } catch (error) {
+      return commandFailure(
+        runtime,
+        error instanceof Error && error.message.startsWith('Usage:') ? 'invalid_routine_command' : 'agent.routines.create.error',
+        error instanceof Error ? error.message : String(error),
+        error instanceof Error && error.message.startsWith('Usage:') ? 2 : 1,
+      );
+    }
+  }
   if (normalized === 'show') {
     const id = rest[0];
     if (!id) return { output: 'Usage: goodvibes-agent routines show <id>', exitCode: 2 };
@@ -363,7 +499,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
   if (normalized === 'reconcile' || normalized === 'sync' || normalized === 'status') {
     const store = routineReceiptStore(runtime);
     const result = await reconcileRoutineScheduleReceipts(
-      resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory),
+      resolveAgentConnectedHostConnection(runtime.configManager, runtime.homeDirectory),
       store.snapshot(),
     );
     return {
@@ -376,7 +512,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
     if (!id) return { output: 'Usage: goodvibes-agent routines receipt <receipt-id>', exitCode: 2 };
     const receipt = routineReceiptStore(runtime).get(id);
     if (!receipt) {
-      const failure: RoutinesCommandFailure = { ok: false, kind: 'routine_schedule_receipt_not_found', error: `Unknown routine schedule receipt: ${id}` };
+      const failure: RoutinesCommandFailure = { ok: false, kind: 'routine_schedule_receipt_not_found', error: `Unknown routine schedule receipt ${id}` };
       return {
         output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
         exitCode: 1,
@@ -396,7 +532,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
     return handleRoutinePromotion(runtime, rest);
   }
   return {
-    output: 'Usage: goodvibes-agent routines [list|enabled|discover|import-discovered <name> --yes|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
+    output: `Usage: goodvibes-agent routines [list|enabled|attention|discover|import-discovered <name> --yes|create --name <name> --description <summary> --steps <steps>|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]`,
     exitCode: 2,
   };
 }

package/src/cli/service-posture.ts

@@ -1,7 +1,7 @@
 import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
 import net from 'node:net';
 import { isAbsolute, join } from 'node:path';
-import type { ConfigManager } from '../config/index.ts';
+import type { ConfigKey, ConfigManager } from '../config/index.ts';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import type { RuntimeEndpointBinding, RuntimeEndpointId } from './endpoints.ts';
 import { classifyBindPosture, isNetworkFacing } from './network-posture.ts';
@@ -32,7 +32,7 @@ export interface CliServiceLogPosture {
   readonly readError?: string;
 }
 
-export interface CliExternalDaemonLifecyclePosture {
+export interface CliExternalHostLifecyclePosture {
   readonly platform: 'manual';
   readonly path: string;
   readonly installed: false;
@@ -54,13 +54,13 @@ export interface CliServicePosture {
     readonly restartOnFailure: boolean;
     readonly daemonEnabled: boolean;
   };
-  readonly managed: CliExternalDaemonLifecyclePosture;
+  readonly managed: CliExternalHostLifecyclePosture;
   readonly endpoints: readonly CliServiceEndpointPosture[];
   readonly log: CliServiceLogPosture;
   readonly issues: readonly string[];
 }
 
-const ENDPOINTS: readonly { readonly id: RuntimeEndpointId; readonly label: string; readonly enabledKey: string }[] = [
+const ENDPOINTS: readonly { readonly id: RuntimeEndpointId; readonly label: string; readonly enabledKey: ConfigKey }[] = [
   { id: 'controlPlane', label: 'runtime connection', enabledKey: 'controlPlane.enabled' },
   { id: 'httpListener', label: 'inbound events endpoint', enabledKey: 'danger.httpListener' },
   { id: 'web', label: 'browser companion route', enabledKey: 'web.enabled' },
@@ -140,10 +140,10 @@ function resolveConfiguredLogPath(runtime: CliServiceRuntime): string | undefine
   return isAbsolute(trimmed) ? trimmed : join(runtime.homeDirectory, trimmed);
 }
 
-function createExternalDaemonLifecycle(logPath: string | undefined): CliExternalDaemonLifecyclePosture {
+function createExternalHostLifecycle(logPath: string | undefined): CliExternalHostLifecyclePosture {
   return {
     platform: 'manual',
-    path: 'connected GoodVibes services',
+    path: 'connected GoodVibes host',
     installed: false,
     autostart: false,
     running: false,
@@ -151,7 +151,7 @@ function createExternalDaemonLifecycle(logPath: string | undefined): CliExternal
     commandPreview: 'managed outside goodvibes-agent',
     suggestedCommands: [],
     lastAction: 'status',
-    pidPath: 'connected GoodVibes services',
+    pidPath: 'connected GoodVibes host',
     lastError: null,
   };
 }
@@ -161,7 +161,7 @@ export async function buildCliServicePosture(
   options: CliServicePostureOptions = {},
 ): Promise<CliServicePosture> {
   const endpoints = await Promise.all(ENDPOINTS.map(async (endpoint): Promise<CliServiceEndpointPosture> => {
-    const enabled = runtime.configManager.get(endpoint.enabledKey as never) === true;
+    const enabled = runtime.configManager.get(endpoint.enabledKey) === true;
     const binding = resolveRuntimeEndpointBinding(runtime.configManager, endpoint.id);
     return {
       id: endpoint.id,
@@ -184,7 +184,7 @@ export async function buildCliServicePosture(
   const issues: string[] = [];
 
   if (serverBackedEnabled && !config.enabled) {
-    issues.push('Connected-service settings are present, but Agent service ownership is disabled by design.');
+    issues.push('Connected-host settings are present, but Agent host ownership is disabled by design.');
   }
   for (const endpoint of endpoints) {
     if (endpoint.enabled && options.probe && endpoint.reachable === false) {
@@ -209,7 +209,7 @@ export async function buildCliServicePosture(
 
   return {
     config,
-    managed: createExternalDaemonLifecycle(configuredLogPath),
+    managed: createExternalHostLifecycle(configuredLogPath),
     endpoints,
     log,
     issues,
@@ -223,21 +223,21 @@ function yesNo(value: boolean): string {
 export function formatCliServicePosture(posture: CliServicePosture, json = false): string {
   if (json) return JSON.stringify(posture, null, 2);
   return [
-    'GoodVibes Agent runtime connection diagnostics',
-    '  ownership: managed outside goodvibes-agent',
-    '  Agent owns lifecycle: no',
+    'GoodVibes Agent connected-host diagnostics',
+    '  lifecycle owner: outside goodvibes-agent',
+    '  Agent starts connected host: no',
     `  external host config present: ${yesNo(posture.config.enabled)}`,
     '  external host lifecycle config: ignored by Agent',
     `  legacy host switch present: ${yesNo(posture.config.daemonEnabled)}`,
     `  log: ${posture.log.path ?? 'n/a'} (${posture.log.exists ? 'present' : 'missing'})`,
     ...(posture.log.readError ? [`  log read error: ${posture.log.readError}`] : []),
     '',
-    'Connected GoodVibes API checks:',
+    'Connected API checks',
     ...posture.endpoints.map((endpoint) =>
-      `  ${endpoint.label}: enabled=${yesNo(endpoint.enabled)} ${endpoint.binding.hostMode} ${endpoint.binding.host}:${endpoint.binding.port} posture=${endpoint.bindPosture.label}${endpoint.reachable === undefined ? '' : ` reachable=${yesNo(endpoint.reachable)}`}`,
+      `  ${endpoint.label} enabled ${yesNo(endpoint.enabled)}  ${endpoint.binding.hostMode} ${endpoint.binding.host}:${endpoint.binding.port}  posture ${endpoint.bindPosture.label}${endpoint.reachable === undefined ? '' : `  reachable ${yesNo(endpoint.reachable)}`}`,
     ),
     '',
-    posture.issues.length === 0 ? 'Readiness: ready' : 'Readiness: needs attention',
+    posture.issues.length === 0 ? 'Readiness ready' : 'Readiness needs attention',
     ...posture.issues.map((issue) => `  - ${issue}`),
   ].join('\n');
 }