@smartmemory/compose 0.1.0

package/lib/cross-layer-audit.js

@@ -0,0 +1,84 @@
+/**
+ * cross-layer-audit.js — Cross-layer scope detection for COMP-DEBUG-1.
+ *
+ * Detects when a bug fix spans multiple repos/layers and should trigger
+ * a grep audit before the fix step proceeds.
+ *
+ * See: docs/features/COMP-DEBUG-1/design.md
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DEFAULT_EXTENSIONS = ['*.py', '*.json', '*.ts', '*.tsx', '*.jsx', '*.yaml'];
+
+const CROSS_LAYER_KEYWORDS = [
+  /openai/i, /groq/i, /anthropic/i, /gpt-4/i, /llama/i,
+  /config\.json/i, /\.env\b/i, /VITE_/,
+  /\brenamed?\b/i, /was previously/i, /changed from/i,
+  /\bcaddy\b/i, /\bproxy\b/i, /\bnginx\b/i, /\broute\b/i,
+];
+
+/**
+ * Load debug discipline config from .compose/compose.json.
+ * Returns defaults if no config exists.
+ */
+export function loadDebugConfig(cwd) {
+  const configPath = join(cwd, '.compose', 'compose.json');
+  const defaults = { cross_layer_repos: [], cross_layer_extensions: DEFAULT_EXTENSIONS };
+  try {
+    if (!existsSync(configPath)) return defaults;
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    const dd = config.debug_discipline ?? {};
+    return {
+      cross_layer_repos: dd.cross_layer_repos ?? defaults.cross_layer_repos,
+      cross_layer_extensions: dd.cross_layer_extensions ?? defaults.cross_layer_extensions,
+    };
+  } catch {
+    return defaults;
+  }
+}
+
+/**
+ * Detects whether a diagnose result indicates cross-layer changes
+ * that need a scope expansion audit.
+ */
+export class CrossLayerAudit {
+  constructor(config) {
+    this.repos = config.cross_layer_repos ?? [];
+    this.extensions = config.cross_layer_extensions ?? DEFAULT_EXTENSIONS;
+  }
+
+  /**
+   * Check if the diagnose result warrants scope expansion.
+   * @param {object} diagnoseResult - output from diagnose step
+   * @returns {{ expand: boolean, trigger: string|null }}
+   */
+  shouldExpand(diagnoseResult) {
+    const hint = diagnoseResult?.scope_hint;
+
+    // Structured detection (primary)
+    if (hint === 'cross-layer') {
+      return { expand: true, trigger: 'scope_hint' };
+    }
+    if (hint === 'single') {
+      return { expand: false, trigger: null };
+    }
+
+    // Keyword fallback (when hint is 'unknown' or absent)
+    const text = [
+      diagnoseResult?.root_cause ?? '',
+      diagnoseResult?.summary ?? '',
+      ...(diagnoseResult?.affected_layers ?? []),
+    ].join(' ');
+
+    for (const kw of CROSS_LAYER_KEYWORDS) {
+      const match = text.match(kw);
+      if (match) {
+        return { expand: true, trigger: `keyword:${match[0]}` };
+      }
+    }
+
+    return { expand: false, trigger: null };
+  }
+}

package/lib/debug-discipline.js

@@ -0,0 +1,173 @@
+/**
+ * debug-discipline.js — Debug Discipline Engine for COMP-DEBUG-1.
+ *
+ * Detects fix-chain thrashing, validates trace evidence, tracks attempts,
+ * and audits cross-layer scope. Called from build.js during fix retry loops.
+ *
+ * See: docs/features/COMP-DEBUG-1/design.md
+ */
+
+import { appendFileSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Fix-Chain Detector
+// ---------------------------------------------------------------------------
+
+/**
+ * Tracks which files are modified across fix iterations.
+ * Detects thrashing: same file touched in multiple iterations.
+ */
+export class FixChainDetector {
+  constructor() {
+    this.fileHits = new Map();
+    this.iteration = 0;
+  }
+
+  recordIteration(filesChanged) {
+    this.iteration++;
+    for (const file of filesChanged) {
+      this.fileHits.set(file, (this.fileHits.get(file) ?? 0) + 1);
+    }
+  }
+
+  detect() {
+    return [...this.fileHits.entries()]
+      .filter(([, count]) => count >= 2)
+      .map(([file, count]) => ({
+        file,
+        iterations: count,
+        level: count >= 3 ? 'critical' : 'warning',
+      }));
+  }
+
+  toJSON() {
+    return {
+      iteration: this.iteration,
+      fileHits: Object.fromEntries(this.fileHits),
+    };
+  }
+
+  static fromJSON(json) {
+    const d = new FixChainDetector();
+    d.iteration = json.iteration ?? 0;
+    d.fileHits = new Map(Object.entries(json.fileHits ?? {}));
+    return d;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Attempt Counter
+// ---------------------------------------------------------------------------
+
+const VISUAL_EXTENSIONS = /\.(css|scss|jsx|tsx)$/i;
+
+/**
+ * Tracks fix attempts and enforces thresholds with escalation.
+ * Visual bugs escalate at attempt 2; all bugs escalate at attempt 5.
+ */
+export class AttemptCounter {
+  constructor() {
+    this.count = 0;
+    this.isVisual = false;
+  }
+
+  record({ filesChanged = [], isVisual = null }) {
+    this.count++;
+    if (isVisual !== null) {
+      this.isVisual = isVisual;
+    } else if (filesChanged.some(f => AttemptCounter.isVisualFile(f))) {
+      this.isVisual = true;
+    }
+  }
+
+  getIntervention() {
+    if (this.count >= 5) return 'escalate';
+    if (this.count >= 3 && !this.isVisual) return 'trace_refresh';
+    if (this.count >= 2 && this.isVisual) return 'escalate';
+    if (this.count >= 2) return 'trace_reminder';
+    return null;
+  }
+
+  static isVisualFile(file) {
+    return VISUAL_EXTENSIONS.test(file);
+  }
+
+  toJSON() {
+    return { count: this.count, isVisual: this.isVisual };
+  }
+
+  static fromJSON(json) {
+    const c = new AttemptCounter();
+    c.count = json.count ?? 0;
+    c.isVisual = json.isVisual ?? false;
+    return c;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Trace Validator
+// ---------------------------------------------------------------------------
+
+const MIN_EVIDENCE_ITEMS = 2;
+const MIN_OUTPUT_LENGTH = 5;
+
+/**
+ * Validates diagnose step output meets trace evidence requirements.
+ * Rejects prose-only analysis without concrete command output.
+ */
+export class TraceValidator {
+  static validate(diagnoseResult) {
+    const evidence = diagnoseResult?.trace_evidence;
+
+    if (!evidence) {
+      return { valid: false, reason: 'trace_evidence is missing or null' };
+    }
+    if (!Array.isArray(evidence) || evidence.length < MIN_EVIDENCE_ITEMS) {
+      return { valid: false, reason: `trace_evidence requires minimum ${MIN_EVIDENCE_ITEMS} items, got ${evidence?.length ?? 0}` };
+    }
+
+    for (const [i, e] of evidence.entries()) {
+      if (!e.command) {
+        return { valid: false, reason: `trace_evidence[${i}] missing command field` };
+      }
+      if (!e.actual_output) {
+        return { valid: false, reason: `trace_evidence[${i}] missing actual_output field` };
+      }
+    }
+
+    const hasSubstantialOutput = evidence.some(e =>
+      typeof e.actual_output === 'string' && e.actual_output.length > MIN_OUTPUT_LENGTH
+    );
+    if (!hasSubstantialOutput) {
+      return { valid: false, reason: `no trace evidence has output longer than ${MIN_OUTPUT_LENGTH} chars` };
+    }
+
+    if (!diagnoseResult.root_cause) {
+      return { valid: false, reason: 'root_cause is missing — connect evidence to a conclusion' };
+    }
+
+    return { valid: true };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Debug Ledger (file-based, upgrades to COMP-HARNESS-9 later)
+// ---------------------------------------------------------------------------
+
+const LEDGER_FILE = 'debug-ledger.jsonl';
+
+/**
+ * Append-only JSONL ledger for debug discipline events.
+ * Writes to .compose/debug-ledger.jsonl.
+ */
+export class DebugLedger {
+  constructor(composeDir) {
+    this.path = join(composeDir, LEDGER_FILE);
+  }
+
+  record(entry) {
+    const line = JSON.stringify({ ts: new Date().toISOString(), ...entry });
+    appendFileSync(this.path, line + '\n', 'utf-8');
+  }
+}

package/lib/feature-json.js

@@ -0,0 +1,106 @@
+/**
+ * feature-json.js — Read, write, and list feature.json files.
+ *
+ * Each feature lives at docs/features/<CODE>/feature.json.
+ * feature.json is the machine-readable source of truth.
+ * ROADMAP.md is generated from these files.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, basename } from 'path';
+import { readdirSync } from 'fs';
+
+/**
+ * @typedef {object} FeatureJson
+ * @property {string} code
+ * @property {string} description
+ * @property {string} status - PLANNED | IN_PROGRESS | PARTIAL | COMPLETE | SUPERSEDED | PARKED
+ * @property {string} [parent] - Parent feature/phase code (e.g., "STRAT-1", "Phase 6")
+ * @property {string} [phase] - Phase heading for ROADMAP grouping
+ * @property {number} [position] - Sort order within phase
+ * @property {string} [complexity] - low | medium | high (from scope step)
+ * @property {object} [profile] - BuildProfile from scope step
+ * @property {string} [created] - ISO date
+ * @property {string} [updated] - ISO date
+ */
+
+/**
+ * Read a single feature.json.
+ *
+ * @param {string} cwd - Project root
+ * @param {string} code - Feature code
+ * @param {string} [featuresDir] - Relative path to features dir (default: docs/features)
+ * @returns {FeatureJson|null}
+ */
+export function readFeature(cwd, code, featuresDir = 'docs/features') {
+  const path = join(cwd, featuresDir, code, 'feature.json');
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write a feature.json, creating the directory if needed.
+ *
+ * @param {string} cwd - Project root
+ * @param {FeatureJson} feature
+ * @param {string} [featuresDir]
+ */
+export function writeFeature(cwd, feature, featuresDir = 'docs/features') {
+  const dir = join(cwd, featuresDir, feature.code);
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, 'feature.json');
+  feature.updated = new Date().toISOString().slice(0, 10);
+  writeFileSync(path, JSON.stringify(feature, null, 2) + '\n');
+}
+
+/**
+ * List all feature.json files in the features directory.
+ *
+ * @param {string} cwd - Project root
+ * @param {string} [featuresDir]
+ * @returns {FeatureJson[]}
+ */
+export function listFeatures(cwd, featuresDir = 'docs/features') {
+  const dir = join(cwd, featuresDir);
+  if (!existsSync(dir)) return [];
+
+  const features = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const fjPath = join(dir, entry.name, 'feature.json');
+    if (!existsSync(fjPath)) continue;
+    try {
+      features.push(JSON.parse(readFileSync(fjPath, 'utf-8')));
+    } catch { /* skip malformed */ }
+  }
+
+  // Sort by phase, then position, then code
+  features.sort((a, b) => {
+    if (a.phase !== b.phase) return (a.phase ?? '').localeCompare(b.phase ?? '');
+    if ((a.position ?? 999) !== (b.position ?? 999)) return (a.position ?? 999) - (b.position ?? 999);
+    return a.code.localeCompare(b.code);
+  });
+
+  return features;
+}
+
+/**
+ * Update a feature's status (and optionally other fields).
+ *
+ * @param {string} cwd
+ * @param {string} code
+ * @param {Partial<FeatureJson>} updates
+ * @param {string} [featuresDir]
+ * @returns {FeatureJson|null} - Updated feature, or null if not found
+ */
+export function updateFeature(cwd, code, updates, featuresDir = 'docs/features') {
+  const feature = readFeature(cwd, code, featuresDir);
+  if (!feature) return null;
+  Object.assign(feature, updates);
+  writeFeature(cwd, feature, featuresDir);
+  return feature;
+}

package/lib/gate-prompt.js

@@ -0,0 +1,291 @@
+/**
+ * gate-prompt.js — CLI readline interface for gate resolution.
+ *
+ * Prompts the user to approve, revise, or kill a gate dispatch,
+ * with interactive Q&A: typing a question dispatches it to an agent
+ * that reads the artifact and answers.
+ */
+import { createInterface } from 'node:readline';
+
+// ---------------------------------------------------------------------------
+// ANSI helpers
+// ---------------------------------------------------------------------------
+
+const ESC = '\x1b[';
+const RESET   = `${ESC}0m`;
+const BOLD    = `${ESC}1m`;
+const DIM     = `${ESC}2m`;
+const CYAN    = `${ESC}36m`;
+const GREEN   = `${ESC}32m`;
+const RED     = `${ESC}31m`;
+const YELLOW  = `${ESC}33m`;
+const GRAY    = `${ESC}90m`;
+
+const OUTCOME_MAP = {
+  a: 'approve',
+  approve: 'approve',
+  r: 'revise',
+  revise: 'revise',
+  k: 'kill',
+  kill: 'kill',
+};
+
+// ---------------------------------------------------------------------------
+// COMP-UX-3b: Generate a recommendation sentence and default action from the
+// gate's artifact assessment (if present in gateExtras.artifactAssessment).
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a 1-sentence recommendation from gate metadata.
+ * Returns { sentence, defaultOutcome } where defaultOutcome is 'approve' or 'revise'.
+ */
+function buildRecommendation(gateDispatch, gateExtras) {
+  const assessment = gateExtras?.artifactAssessment;
+  const summary = gateExtras?.summary;
+
+  // If there's an explicit summary from Stratum, use it
+  // Avoid false positives: "No critical findings" should NOT trigger revise
+  if (summary) {
+    const hasIssue = /(?<!\bno\s)(?<!\b0\s)\b(critical|error|fail|missing)\b/i.test(summary);
+    const defaultOutcome = hasIssue ? 'revise' : 'approve';
+    const action = defaultOutcome === 'approve' ? 'Ship it?' : 'Revise?';
+    return { sentence: `${summary} ${action}`, defaultOutcome };
+  }
+
+  if (!assessment) {
+    return { sentence: null, defaultOutcome: null };
+  }
+
+  // Missing artifact — never recommend approve
+  if (assessment.exists === false) {
+    return { sentence: 'Required artifact is missing. Revise?', defaultOutcome: 'revise' };
+  }
+
+  const { completeness, wordCount, sections, meetsMinWordCount, findings } = assessment;
+
+  // Count critical findings
+  const criticalCount = (findings ?? []).filter(
+    f => /critical|error|fatal/i.test(f.severity ?? f.level ?? '')
+  ).length;
+  const findingCount = (findings ?? []).length;
+  const missingCount = sections?.missing?.length ?? 0;
+
+  if (criticalCount > 0) {
+    return {
+      sentence: `${criticalCount} critical finding${criticalCount > 1 ? 's' : ''}. Revise?`,
+      defaultOutcome: 'revise',
+    };
+  }
+
+  if (!meetsMinWordCount && wordCount !== undefined) {
+    return {
+      sentence: `Artifact is thin (${wordCount} words). Revise?`,
+      defaultOutcome: 'revise',
+    };
+  }
+
+  if (missingCount > 0) {
+    return {
+      sentence: `Missing ${missingCount} section${missingCount > 1 ? 's' : ''} (${(sections.missing ?? []).slice(0, 2).join(', ')}). Revise?`,
+      defaultOutcome: 'revise',
+    };
+  }
+
+  if (findingCount > 0) {
+    return {
+      sentence: `${findingCount} finding${findingCount > 1 ? 's' : ''}, ${Math.round((completeness ?? 1) * 100)}% complete. Ship it?`,
+      defaultOutcome: 'approve',
+    };
+  }
+
+  const pct = completeness !== undefined ? `${Math.round(completeness * 100)}% complete` : null;
+  const wc = wordCount !== undefined ? `${wordCount} words` : null;
+  const detail = [pct, wc].filter(Boolean).join(', ');
+  return {
+    sentence: detail ? `${detail}. Ship it?` : 'Ready to proceed? Ship it?',
+    defaultOutcome: 'approve',
+  };
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+/**
+ * Render a boxed gate panel with artifact, phase, and action info.
+ * COMP-UX-3b: Shows a recommendation sentence and accepts Enter as default.
+ */
+function drawGatePanel(out, gateDispatch, { artifact, gateExtras } = {}) {
+  const { step_id, on_approve, on_revise, on_kill } = gateDispatch;
+  const cols = (out.columns ?? process.stdout.columns) || 80;
+  const innerW = Math.max(40, Math.min(cols - 6, 70));
+
+  const pad = (str, w) => {
+    const plainLen = str.replace(/\x1b\[[0-9;]*m/g, '').length;
+    return plainLen >= w ? str : str + ' '.repeat(w - plainLen);
+  };
+
+  const line = (content) => `  \u2502 ${pad(content, innerW)} \u2502`;
+  const empty = line('');
+  const topLabel = ` Gate: ${step_id} `;
+  const topRule = '\u2500'.repeat(Math.max(0, innerW + 2 - topLabel.length - 1));
+  const bottomRule = '\u2500'.repeat(innerW + 2);
+
+  // COMP-UX-3b: build recommendation
+  const { sentence: recSentence, defaultOutcome } = buildRecommendation(gateDispatch, gateExtras);
+  const recColor = defaultOutcome === 'approve' ? GREEN : YELLOW;
+  const defaultLabel = defaultOutcome === 'approve' ? 'a' : 'r';
+
+  out.write(`  \u250C\u2500${BOLD}${CYAN}${topLabel}${RESET}${topRule}\u2510\n`);
+  out.write(empty + '\n');
+
+  if (artifact) {
+    out.write(line(`${DIM}Artifact:${RESET} ${artifact}`) + '\n');
+  }
+
+  if (gateExtras) {
+    const from = gateExtras.fromPhase ?? '?';
+    const to = gateExtras.toPhase ?? '?';
+    out.write(line(`${DIM}Phase:${RESET}    ${from} \u2192 ${to}`) + '\n');
+  }
+
+  // Recommendation line
+  if (recSentence) {
+    out.write(empty + '\n');
+    out.write(line(`${recColor}${BOLD}${recSentence}${RESET}`) + '\n');
+    out.write(line(`${DIM}[Enter] = ${defaultOutcome}   [d] = show details${RESET}`) + '\n');
+  }
+
+  out.write(empty + '\n');
+  out.write(line(`${GREEN}[a]${RESET} Approve  \u2192  ${on_approve ?? '(complete)'}`) + '\n');
+  out.write(line(`${YELLOW}[r]${RESET} Revise   \u2192  ${on_revise ?? '(kill)'}`) + '\n');
+  out.write(line(`${RED}[k]${RESET} Kill     \u2192  ${on_kill ?? '(terminate)'}`) + '\n');
+  out.write(empty + '\n');
+  out.write(line(`${DIM}Type a question to ask the agent.${RESET}`) + '\n');
+  out.write(`  \u2514${bottomRule}\u2518\n`);
+
+  return { defaultOutcome, defaultLabel };
+}
+
+/**
+ * Prompt the user to resolve a gate dispatch.
+ *
+ * @param {object} gateDispatch - Gate dispatch with step_id, on_approve, on_revise, on_kill
+ * @param {object} [options]
+ * @param {NodeJS.ReadableStream} [options.input]
+ * @param {NodeJS.WritableStream} [options.output]
+ * @param {string}   [options.artifact]    - Path to the artifact being reviewed
+ * @param {Function} [options.askAgent]    - async (question, artifact) => answer string
+ * @param {object}   [options.gateExtras]  - { fromPhase, toPhase } for panel display
+ * @returns {Promise<{ outcome: string, rationale: string }>}
+ */
+export async function promptGate(gateDispatch, { input, output, artifact, askAgent, gateExtras, nonInteractive } = {}) {
+  if (nonInteractive) {
+    return { outcome: 'approve', rationale: 'auto-approved (--all mode)' };
+  }
+
+  const rl = createInterface({
+    input: input ?? process.stdin,
+    output: output ?? process.stdout,
+  });
+
+  try {
+    const { step_id, on_approve, on_revise, on_kill } = gateDispatch;
+
+    // COMP-UX-3b: drawGatePanel returns recommendation context
+    const { defaultOutcome } = drawGatePanel(rl.output, gateDispatch, { artifact, gateExtras });
+
+    // Full assessment detail for 'd' key
+    const fullDetail = (() => {
+      const assessment = gateExtras?.artifactAssessment;
+      if (!assessment) return null;
+      const lines = [];
+      if (assessment.wordCount !== undefined) lines.push(`Words: ${assessment.wordCount}`);
+      if (assessment.completeness !== undefined) lines.push(`Completeness: ${Math.round(assessment.completeness * 100)}%`);
+      if (assessment.sections?.missing?.length) lines.push(`Missing sections: ${assessment.sections.missing.join(', ')}`);
+      if (!assessment.meetsMinWordCount) lines.push('Below minimum word count');
+      const findings = assessment.findings ?? [];
+      if (findings.length) {
+        lines.push(`Findings (${findings.length}):`);
+        for (const f of findings.slice(0, 5)) {
+          lines.push(`  - ${f.severity ?? f.level ?? '?'}: ${f.message ?? f.text ?? JSON.stringify(f)}`);
+        }
+        if (findings.length > 5) lines.push(`  ... and ${findings.length - 5} more`);
+      }
+      return lines.length ? lines.join('\n') : null;
+    })();
+
+    const notes = [];
+    let outcome;
+
+    while (!outcome) {
+      const raw = await ask(rl, '\n> ');
+      const trimmed = raw.trim();
+
+      // COMP-UX-3b: Enter alone → use recommended default action (only if recommendation was shown)
+      if (!trimmed && defaultOutcome) {
+        outcome = defaultOutcome;
+        rl.output.write(`  (using recommended: ${defaultOutcome})\n`);
+        continue;
+      }
+      if (!trimmed) continue;  // no recommendation — ignore bare Enter
+
+      const key = trimmed.toLowerCase();
+
+      // COMP-UX-3b: 'd' shows full artifact detail
+      if (key === 'd' || key === 'detail' || key === 'details') {
+        if (fullDetail) {
+          rl.output.write('\n  Artifact detail:\n');
+          for (const l of fullDetail.split('\n')) rl.output.write(`  ${l}\n`);
+        } else {
+          rl.output.write('  (no artifact assessment available)\n');
+        }
+        continue;
+      }
+
+      if (OUTCOME_MAP[key]) {
+        outcome = OUTCOME_MAP[key];
+      } else if (askAgent) {
+        // Dispatch question to agent
+        rl.output.write('  Asking agent...\n');
+        try {
+          const answer = await askAgent(trimmed, artifact);
+          rl.output.write(`\n  ${answer}\n`);
+        } catch (err) {
+          rl.output.write(`  (agent error: ${err.message})\n`);
+        }
+        notes.push(trimmed);
+      } else {
+        // No agent available — just collect as notes
+        notes.push(trimmed);
+        rl.output.write('  (noted — enter a/r/k when ready to decide)\n');
+      }
+    }
+
+    // Build rationale
+    let rationale;
+    if (notes.length > 0) {
+      rationale = notes.join('\n');
+      const addMore = await ask(rl, '  Additional rationale (or Enter to use notes): ');
+      if (addMore.trim()) {
+        rationale += '\n' + addMore.trim();
+      }
+    } else if (outcome === 'approve') {
+      rationale = 'approved';
+    } else {
+      while (!rationale) {
+        const raw = await ask(rl, 'Rationale: ');
+        const trimmed = raw.trim();
+        if (trimmed) {
+          rationale = trimmed;
+        } else {
+          rl.output.write('Rationale required.\n');
+        }
+      }
+    }
+
+    return { outcome, rationale };
+  } finally {
+    rl.close();
+  }
+}