@aifabrix/builder 2.49.2 → 2.51.0

package/scripts/lib/plan-prevalidate-gates.js

@@ -0,0 +1,337 @@
+/**
+ * @fileoverview Pre-implementation plan validation gates (/validate-plan).
+ */
+
+/* eslint-disable valid-jsdoc, require-jsdoc */
+
+'use strict';
+
+const {
+  statSync,
+  mkdirSync,
+  writeFileSync
+} = require('../../lib/internal/fs-real-sync');
+const path = require('path');
+const { loadPlanFile, hasSurface } = require('./plan-parse');
+
+const REPO_ROOT = path.resolve(__dirname, '../..');
+const PREVALIDATE_REPORT_DIR = path.join(REPO_ROOT, 'temp/plan-prevalidation');
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function escapeMarkdownCell(value) {
+  return String(value ?? '')
+    .replace(/\r?\n+/g, ' ')
+    .replace(/\|/g, '\\|')
+    .trim();
+}
+
+/**
+ * @typedef {{ label: string, status: 'pass' | 'fail' | 'warn' | 'skip', detail?: string }} GateResult
+ */
+
+/**
+ * @param {string} label
+ * @param {'pass' | 'fail' | 'warn' | 'skip'} status
+ * @param {string} [detail]
+ * @returns {GateResult}
+ */
+function gate(label, status, detail) {
+  return { label, status, detail };
+}
+
+/**
+ * @param {string} body
+ * @param {string} heading
+ * @returns {boolean}
+ */
+function hasHeading(body, heading) {
+  const re = new RegExp(`^## ${heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm');
+  return re.test(body);
+}
+
+/**
+ * @param {string} body
+ * @returns {string | null}
+ */
+function extractReportStatus(body) {
+  const reportMatch = body.match(/## Plan Validation Report[\s\S]*?\*\*Status\*\*:\s*(.+)/i);
+  if (!reportMatch) {
+    return null;
+  }
+  const line = reportMatch[1].trim();
+  if (/VALIDATED/i.test(line) && !/NEEDS|INCOMPLETE/i.test(line)) {
+    return 'validated';
+  }
+  if (/NEEDS UPDATES/i.test(line)) {
+    return 'needs-updates';
+  }
+  if (/INCOMPLETE/i.test(line)) {
+    return 'incomplete';
+  }
+  return null;
+}
+
+/**
+ * @param {string} body
+ * @param {string} subsection
+ * @returns {boolean}
+ */
+function hasReportSubsection(body, subsection) {
+  const reportIdx = body.indexOf('## Plan Validation Report');
+  if (reportIdx < 0) {
+    return false;
+  }
+  const report = body.slice(reportIdx);
+  const re = new RegExp(`^### ${subsection.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'm');
+  return re.test(report);
+}
+
+/**
+ * @param {string} planPath
+ * @param {string | undefined} lastValidatedAt
+ * @returns {boolean}
+ */
+function isValidationStale(planPath, lastValidatedAt) {
+  if (!lastValidatedAt) {
+    return false;
+  }
+  const validatedMs = Date.parse(String(lastValidatedAt));
+  if (Number.isNaN(validatedMs)) {
+    return false;
+  }
+  const mtime = statSync(planPath).mtimeMs;
+  return mtime > validatedMs + 86400000;
+}
+
+/**
+ * @param {string} body
+ * @returns {boolean}
+ */
+function needsManualSection(body, meta) {
+  const reportIdx = body.indexOf('## Plan Validation Report');
+  const planBody = reportIdx >= 0 ? body.slice(0, reportIdx) : body;
+  const todos = Array.isArray(meta.todos) ? meta.todos : [];
+  const todoText = todos.map((t) => `${t.content} ${t.id}`).join(' ');
+  const combined = `${planBody}\n${todoText}`;
+  return /manual|pilot|live proof|e2e smoke|container proof|dev-reload/i.test(combined);
+}
+
+/**
+ * @param {Record<string, unknown>} meta
+ * @returns {boolean}
+ */
+function isCodePlan(meta) {
+  return meta.planType === 'code';
+}
+
+/**
+ * @param {Record<string, unknown>} meta
+ * @returns {boolean}
+ */
+function isMetaPlan(meta) {
+  return meta.planType === 'meta';
+}
+
+/**
+ * @param {string} planPath
+ * @param {{ allowNeedsUpdates?: boolean, repoProfile?: string }} [opts]
+ */
+function runPrevalidateGates(planPath, opts = {}) {
+  const loaded = loadPlanFile(planPath);
+  if (!loaded) {
+    return {
+      gates: [gate('plan-parse', 'fail', 'invalid or missing frontmatter')],
+      reportStatus: 'incomplete',
+      planValidatedStatus: 'incomplete',
+      meta: {},
+      body: ''
+    };
+  }
+
+  const { meta, body } = loaded;
+  const gates = [];
+  const code = isCodePlan(meta);
+  const metaPlan = isMetaPlan(meta);
+
+  if (!meta.name && !meta.overview) {
+    gates.push(gate('frontmatter-name', 'fail', 'name or overview required'));
+  } else {
+    gates.push(gate('frontmatter-name', 'pass'));
+  }
+
+  if (!Array.isArray(meta.todos) || meta.todos.length === 0) {
+    gates.push(gate('todos', 'fail', 'frontmatter todos required'));
+  } else {
+    gates.push(gate('todos', 'pass', `${meta.todos.length} todo(s)`));
+  }
+
+  const scopeSections = ['Scope', 'Rules and Standards', 'Before Development', 'Definition of Done'];
+  for (const section of scopeSections) {
+    if (!hasHeading(body, section)) {
+      gates.push(gate(`section-${section}`, 'fail', `missing ## ${section}`));
+    } else {
+      gates.push(gate(`section-${section}`, 'pass'));
+    }
+  }
+
+  if (hasHeading(body, 'Scope')) {
+    const scopeOk =
+      /### In scope/i.test(body) && /### Out of scope/i.test(body);
+    gates.push(
+      scopeOk
+        ? gate('scope-boundaries', 'pass')
+        : gate('scope-boundaries', 'fail', 'Scope needs ### In scope and ### Out of scope')
+    );
+  }
+
+  if (code) {
+    for (const section of ['Architecture alignment', 'Code reuse scan', 'Expected Automated Tests']) {
+      gates.push(
+        hasHeading(body, section)
+          ? gate(`section-${section}`, 'pass')
+          : gate(`section-${section}`, 'fail', `code plan missing ## ${section}`)
+      );
+    }
+    if (!hasHeading(body, 'File Size Reduction Candidates')) {
+      gates.push(gate('file-size-section', 'warn', 'missing ## File Size Reduction Candidates'));
+    } else {
+      gates.push(gate('file-size-section', 'pass'));
+    }
+    if (hasSurface(meta, 'api') && !meta.apiTiers) {
+      gates.push(gate('api-tiers', 'fail', 'api surface requires apiTiers in frontmatter'));
+    } else if (hasSurface(meta, 'api')) {
+      gates.push(gate('api-tiers', 'pass'));
+    } else {
+      gates.push(gate('api-tiers', 'skip', 'no api surface'));
+    }
+  } else if (metaPlan) {
+    gates.push(gate('architecture-section', 'skip', 'meta plan'));
+    gates.push(gate('reuse-section', 'skip', 'meta plan'));
+    gates.push(gate('automated-tests-section', 'skip', 'meta plan'));
+  } else {
+    gates.push(gate('code-sections', 'skip', `planType=${meta.planType || 'unknown'}`));
+  }
+
+  if (code && needsManualSection(body, meta) && !hasHeading(body, 'Manual testing')) {
+    gates.push(gate('manual-testing-section', 'fail', 'manual scope detected — add ## Manual testing'));
+  } else if (metaPlan) {
+    gates.push(gate('manual-testing-section', 'skip', 'meta plan'));
+  } else if (needsManualSection(body, meta)) {
+    gates.push(gate('manual-testing-section', 'pass'));
+  } else {
+    gates.push(gate('manual-testing-section', 'skip', 'no manual scope'));
+  }
+
+  if (!hasHeading(body, 'Plan Validation Report')) {
+    gates.push(gate('validation-report', 'fail', 'missing ## Plan Validation Report'));
+  } else {
+    gates.push(gate('validation-report', 'pass'));
+    const reportStatus = extractReportStatus(body);
+    if (!reportStatus) {
+      gates.push(gate('report-status', 'fail', 'report missing **Status**: VALIDATED line'));
+    } else if (reportStatus === 'validated') {
+      gates.push(gate('report-status', 'pass', 'VALIDATED'));
+    } else if (reportStatus === 'needs-updates') {
+      gates.push(
+        gate('report-status', opts.allowNeedsUpdates ? 'warn' : 'fail', 'NEEDS UPDATES')
+      );
+    } else {
+      gates.push(gate('report-status', 'fail', 'INCOMPLETE'));
+    }
+
+    if (code) {
+      for (const sub of [
+        'Architecture alignment',
+        'Code reuse scan',
+        'Testing strategy',
+        'Manual testing and approval'
+      ]) {
+        gates.push(
+          hasReportSubsection(body, sub)
+            ? gate(`report-${sub}`, 'pass')
+            : gate(`report-${sub}`, 'fail', `report missing ### ${sub}`)
+        );
+      }
+    }
+  }
+
+  if (isValidationStale(planPath, meta.lastValidatedAt)) {
+    gates.push(gate('staleness', 'fail', 'plan modified after lastValidatedAt — re-validate'));
+  } else if (meta.lastValidatedAt) {
+    gates.push(gate('staleness', 'pass'));
+  } else {
+    gates.push(gate('staleness', 'skip', 'not yet validated'));
+  }
+
+  const hasFail = gates.some((g) => g.status === 'fail');
+  const hasWarn = gates.some((g) => g.status === 'warn');
+  let planValidatedStatus = 'validated';
+  if (hasFail) {
+    planValidatedStatus = 'incomplete';
+  } else if (hasWarn) {
+    planValidatedStatus = 'needs-updates';
+  }
+
+  const reportStatus = extractReportStatus(body) || planValidatedStatus;
+  if (reportStatus !== 'validated') {
+    planValidatedStatus = reportStatus === 'needs-updates' ? 'needs-updates' : 'incomplete';
+  }
+  if (hasFail) {
+    planValidatedStatus = 'incomplete';
+  }
+
+  return { gates, reportStatus, planValidatedStatus, meta, body };
+}
+
+/**
+ * @param {object} params
+ * @returns {string}
+ */
+function buildPrevalidateReport(params) {
+  const { planPath, planName, actor, runAt, gates, planValidatedStatus, reportStatus } = params;
+  const lines = [
+    '# Plan pre-validation summary',
+    '',
+    '| Field | Value |',
+    '| --- | --- |',
+    `| **Plan** | \`${planName}\` |`,
+    `| **Stamp status** | \`${planValidatedStatus}\` |`,
+    `| **Report status** | \`${reportStatus || 'unknown'}\` |`,
+    `| **Run at** | ${runAt} |`,
+    `| **Validated by** | ${actor || '_not set_'} |`,
+    `| **Plan file** | \`${path.relative(REPO_ROOT, planPath)}\` |`,
+    '',
+    '## Gates',
+    '',
+    '| Gate | Result | Detail |',
+    '| --- | --- | --- |'
+  ];
+  for (const g of gates) {
+    lines.push(`| ${escapeMarkdownCell(g.label)} | ${escapeMarkdownCell(g.status)} | ${escapeMarkdownCell(g.detail || '')} |`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+/**
+ * @param {string} content
+ * @param {string} planBaseName
+ */
+function writePrevalidateReport(content, planBaseName) {
+  mkdirSync(PREVALIDATE_REPORT_DIR, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  writeFileSync(path.join(PREVALIDATE_REPORT_DIR, `${planBaseName}.${stamp}.md`), content, 'utf8');
+  writeFileSync(path.join(PREVALIDATE_REPORT_DIR, 'LATEST.md'), content, 'utf8');
+}
+
+module.exports = {
+  PREVALIDATE_REPORT_DIR,
+  runPrevalidateGates,
+  buildPrevalidateReport,
+  writePrevalidateReport,
+  hasHeading,
+  extractReportStatus,
+  isValidationStale
+};

package/scripts/lib/plan-run-core.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Plan run and archive core (miso / builder).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { DONE_DIR, REQUIRE_APPROVAL_TO_ARCHIVE } = require('./plan-config');
+const { resolvePlanPath, patchPlanMeta, die } = require('./plan-meta');
+const { loadPlanFile } = require('./plan-parse');
+const { runAllGates } = require('./plan-gates');
+const { buildSummaryMarkdown, writeReport } = require('./plan-run-report');
+const { resolveActor } = require('./plan-actor');
+
+/**
+ * @param {import('./plan-gates').GateResult[]} gates
+ */
+function gatesPassing(gates) {
+  return gates.filter((g) => g.status === 'fail').length === 0;
+}
+
+/**
+ * @param {string} planInput
+ * @param {{ actorName?: string }} [opts]
+ */
+function runPlan(planInput, opts = {}) {
+  const planPath = resolvePlanPath(planInput);
+  const actorInfo = resolveActor(opts.actorName);
+  const runAt = new Date().toISOString();
+  const planName = path.basename(planPath, '.plan.md');
+  console.log(`Validating: ${planName}\n`);
+
+  const result = runAllGates(planPath);
+
+  let overallStatus = 'PASS';
+  if (!gatesPassing(result.gates)) {
+    overallStatus = 'FAIL';
+  } else if (result.gates.some((g) => g.status === 'warn')) {
+    overallStatus = 'PASS_WITH_WARNINGS';
+  }
+  if (result.blockingPending.length) {
+    overallStatus = 'FAIL';
+  }
+
+  for (const g of result.gates) {
+    const prefix =
+      g.status === 'pass' ? '✔' : g.status === 'warn' ? '⚠' : g.status === 'skip' ? '○' : '✖';
+    console.log(`${prefix} ${g.label}${g.detail ? ` — ${g.detail}` : ''}`);
+  }
+
+  const summary = buildSummaryMarkdown({
+    planPath,
+    planName,
+    actor: actorInfo?.displayName,
+    runAt,
+    gates: result.gates,
+    todos: result.todos,
+    blockingPending: result.blockingPending,
+    manualPending: result.manualPending,
+    overallStatus
+  });
+  writeReport(summary, planName);
+
+  if (!gatesPassing(result.gates) || result.blockingPending.length) {
+    process.exit(1);
+  }
+
+  return { planPath, planName, summary, overallStatus };
+}
+
+/**
+ * @param {string} planInput
+ * @param {string} [summary]
+ * @param {{ allowUnapproved?: boolean }} [opts]
+ */
+function archivePlan(planInput, summary, opts = {}) {
+  const planPath = resolvePlanPath(planInput);
+  const planName = path.basename(planPath, '.plan.md');
+  const loaded = loadPlanFile(planPath);
+  if (
+    REQUIRE_APPROVAL_TO_ARCHIVE &&
+    loaded &&
+    !loaded.meta.approvedBy &&
+    !opts.allowUnapproved
+  ) {
+    die('Plan not approved — run plan-approve first or use --allow-unapproved');
+  }
+
+  fs.mkdirSync(DONE_DIR, { recursive: true });
+  const dest = path.join(DONE_DIR, path.basename(planPath));
+  if (fs.existsSync(dest)) {
+    die(`Already archived: ${dest}`);
+  }
+  fs.renameSync(planPath, dest);
+  if (summary) {
+    fs.writeFileSync(path.join(DONE_DIR, `${planName}.validation.md`), summary, 'utf8');
+  }
+  console.log(`✔ Archived → ${dest}`);
+  return dest;
+}
+
+/**
+ * @param {string} planInput
+ * @param {string} [actorOverride]
+ */
+function approvePlan(planInput, actorOverride) {
+  const planPath = resolvePlanPath(planInput);
+  const actor = resolveActor(actorOverride);
+  const name = actor?.displayName || actorOverride;
+  if (!name) {
+    die('Set actor first: node scripts/plan-set-actor.js "Your Name"');
+  }
+  const today = new Date().toISOString().slice(0, 10);
+  patchPlanMeta(planPath, 'approvedBy', name);
+  patchPlanMeta(planPath, 'approvedAt', today);
+  patchPlanMeta(planPath, 'status', 'approved');
+  console.log(`✔ Approved ${path.basename(planPath)} by ${name} on ${today}`);
+}
+
+module.exports = {
+  runPlan,
+  archivePlan,
+  approvePlan
+};

package/scripts/lib/plan-run-report.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Plan run report writer (shared).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { REPORT_DIR } = require('./plan-config');
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function escapeMarkdownCell(value) {
+  return String(value ?? '')
+    .replace(/\r?\n+/g, ' ')
+    .replace(/\|/g, '\\|')
+    .trim();
+}
+
+/**
+ * @param {object} params
+ * @returns {string}
+ */
+function buildSummaryMarkdown(params) {
+  const {
+    planPath,
+    planName,
+    actor,
+    runAt,
+    gates,
+    todos,
+    blockingPending,
+    manualPending,
+    overallStatus
+  } = params;
+
+  const lines = [
+    '# Plan validation summary',
+    '',
+    '| Field | Value |',
+    '| --- | --- |',
+    `| **Plan** | \`${planName}\` |`,
+    `| **Status** | **${overallStatus}** |`,
+    `| **Run at** | ${runAt} |`,
+    `| **Validated by** | ${actor || '_not set_'} |`,
+    `| **Plan file** | \`${planPath}\` |`,
+    '',
+    '## Quality gates',
+    '',
+    '| Gate | Result | Detail |',
+    '| --- | --- | --- |'
+  ];
+
+  for (const g of gates) {
+    const icon = g.status === 'pass' ? 'pass' : g.status === 'warn' ? 'warn' : 'FAIL';
+    lines.push(`| ${escapeMarkdownCell(g.label)} | ${icon} | ${escapeMarkdownCell(g.detail || '')} |`);
+  }
+
+  lines.push('', '## Todos', '', '| ID | Status | Content |', '| --- | --- | --- |');
+  for (const t of todos) {
+    lines.push(
+      `| ${escapeMarkdownCell(t.id)} | ${escapeMarkdownCell(t.status)} | ${escapeMarkdownCell(t.content).slice(0, 100)} |`
+    );
+  }
+
+  if (blockingPending.length) {
+    lines.push('', '### Blocking', '');
+    for (const t of blockingPending) {
+      lines.push(`- **${t.id}**: ${t.content}`);
+    }
+  }
+  if (manualPending.length) {
+    lines.push('', '### Manual (non-blocking)', '');
+    for (const t of manualPending) {
+      lines.push(`- **${t.id}**: ${t.content}`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+/**
+ * @param {string} content
+ * @param {string} planBaseName
+ */
+function writeReport(content, planBaseName) {
+  fs.mkdirSync(REPORT_DIR, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  fs.writeFileSync(path.join(REPORT_DIR, `${planBaseName}.${stamp}.md`), content, 'utf8');
+  fs.writeFileSync(path.join(REPORT_DIR, 'LATEST.md'), content, 'utf8');
+  console.log('Report: temp/plan-validation/LATEST.md');
+}
+
+/**
+ * @param {string} planBaseName
+ * @returns {{ summary: string, overallStatus: string } | null}
+ */
+function readLatestReportForPlan(planBaseName) {
+  const latest = path.join(REPORT_DIR, 'LATEST.md');
+  if (!fs.existsSync(latest)) {
+    return null;
+  }
+  const summary = fs.readFileSync(latest, 'utf8');
+  const planMatch = summary.match(/\|\s*\*\*Plan\*\*\s*\|\s*`([^`]+)`\s*\|/);
+  if (!planMatch || planMatch[1] !== planBaseName) {
+    return null;
+  }
+  const statusMatch = summary.match(/\|\s*\*\*Status\*\*\s*\|\s*\*\*([^*]+)\*\*\s*\|/);
+  const overallStatus = statusMatch ? statusMatch[1].trim() : '';
+  return { summary, overallStatus };
+}
+
+module.exports = {
+  buildSummaryMarkdown,
+  writeReport,
+  readLatestReportForPlan
+};

package/scripts/plan-approve.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+'use strict';
+
+const { resolvePlanPath, patchPlanMeta, die } = require('./lib/plan-meta');
+const { resolveActor } = require('./lib/plan-actor');
+
+const planInput = process.argv[2];
+if (!planInput) {
+  die('Usage: node scripts/plan-approve.js <plan-path-or-id>');
+}
+
+const planPath = resolvePlanPath(planInput);
+const actor = resolveActor(process.argv[3]);
+const name = actor?.displayName || process.argv[3];
+if (!name) {
+  die('Set actor first via /validate-implementation (plan-set-actor)');
+}
+
+const today = new Date().toISOString().slice(0, 10);
+patchPlanMeta(planPath, 'approvedBy', name);
+patchPlanMeta(planPath, 'approvedAt', today);
+patchPlanMeta(planPath, 'status', 'approved');
+console.log(`✔ Approved ${planPath} by ${name} on ${today}`);

package/scripts/plan-archive.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+'use strict';
+
+const { runPlan, archivePlan } = require('./lib/plan-run-core');
+const { resolvePlanPath } = require('./lib/plan-meta');
+const { readLatestReportForPlan } = require('./lib/plan-run-report');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const planInput = args.find((a) => !a.startsWith('--'));
+const allowUnapproved = args.includes('--allow-unapproved');
+const revalidate = args.includes('--revalidate');
+
+if (!planInput) {
+  console.error(
+    'Usage: node scripts/plan-archive.js <plan-path-or-id> [--allow-unapproved] [--revalidate]'
+  );
+  process.exit(1);
+}
+
+const planPath = resolvePlanPath(planInput);
+const planName = path.basename(planPath, '.plan.md');
+
+let summary = '';
+let runSummary = '';
+
+if (!revalidate) {
+  const cached = readLatestReportForPlan(planName);
+  if (cached) {
+    if (cached.overallStatus !== 'PASS' && cached.overallStatus !== 'PASS_WITH_WARNINGS') {
+      console.error(
+        `Latest report for ${planName} is ${cached.overallStatus} — run plan-run.js or use --revalidate after fixing`
+      );
+      process.exit(1);
+    }
+    summary = cached.summary;
+    console.log('Using cached report: temp/plan-validation/LATEST.md');
+  }
+}
+
+if (!summary) {
+  const result = runPlan(planInput);
+  runSummary = result.summary;
+  summary = runSummary;
+}
+
+archivePlan(planPath, summary, { allowUnapproved });
+console.log(`Plan archived: ${planName}`);

package/scripts/plan-run.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+'use strict';
+
+const { runPlan } = require('./lib/plan-run-core');
+
+const planInput = process.argv[2];
+if (!planInput) {
+  console.error('Usage: node scripts/plan-run.js <plan-path-or-id>');
+  process.exit(1);
+}
+
+runPlan(planInput);

package/scripts/plan-set-actor.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+/**
+ * Save plan validator display name to ~/.aifabrix/plan-actor.yaml (shared across repos).
+ *
+ * @example node scripts/plan-set-actor.js "Your Name"
+ */
+
+'use strict';
+
+const { saveActor } = require('./lib/plan-actor');
+
+const name = process.argv.slice(2).join(' ').trim();
+if (!name) {
+  console.error('Usage: node scripts/plan-set-actor.js "Your Name"');
+  process.exit(1);
+}
+
+const actorPath = saveActor(name);
+console.log(`✔ Saved actor: ${name}`);
+console.log(`  ${actorPath}`);