godpowers 1.6.17 → 1.6.20

package/lib/release-surface-sync.js

@@ -0,0 +1,153 @@
+/**
+ * Release surface sync.
+ *
+ * Detects whether release-facing repo surfaces agree before a package or tag
+ * is treated as ready: package metadata, lockfile, release notes, changelog,
+ * README badge, release checklist, and package payload guardrails.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const LOG_PATH = '.godpowers/surface/RELEASE-SURFACE-SYNC.md';
+
+const REQUIRED_PACKAGE_GUARDS = [
+  'lib/route-quality-sync.js',
+  'lib/recipe-coverage-sync.js',
+  'lib/release-surface-sync.js'
+];
+
+function read(projectRoot, relPath) {
+  const file = path.join(projectRoot, relPath);
+  if (!fs.existsSync(file)) return '';
+  return fs.readFileSync(file, 'utf8');
+}
+
+function write(projectRoot, relPath, content) {
+  const file = path.join(projectRoot, relPath);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+}
+
+function readJson(projectRoot, relPath) {
+  try {
+    return JSON.parse(read(projectRoot, relPath));
+  } catch (err) {
+    return null;
+  }
+}
+
+function addCheck(checks, id, status, relPath, message, opts = {}) {
+  checks.push({
+    area: 'release-surface',
+    id,
+    status,
+    path: relPath,
+    message,
+    severity: opts.severity || (status === 'fresh' ? 'info' : 'warning'),
+    spawn: opts.spawn || null
+  });
+}
+
+function detect(projectRoot) {
+  const checks = [];
+  const pkg = readJson(projectRoot, 'package.json') || {};
+  const lock = readJson(projectRoot, 'package-lock.json') || {};
+  const version = pkg.version || '0.0.0';
+
+  addCheck(
+    checks,
+    'package-lock-version',
+    lock.version === version ? 'fresh' : 'stale',
+    'package-lock.json',
+    lock.version === version
+      ? 'package-lock.json version matches package.json.'
+      : `package-lock.json version ${lock.version || 'missing'} does not match package.json ${version}.`
+  );
+
+  const surfaces = [
+    ['readme-version-badge', 'README.md', `version-${version}-blue`],
+    ['changelog-version', 'CHANGELOG.md', `## [${version}]`],
+    ['release-version', 'RELEASE.md', `Godpowers ${version}`],
+    ['release-checklist-route-quality', 'docs/RELEASE-CHECKLIST.md', 'route-quality-sync'],
+    ['release-checklist-recipe-coverage', 'docs/RELEASE-CHECKLIST.md', 'recipe-coverage-sync'],
+    ['release-checklist-release-surface', 'docs/RELEASE-CHECKLIST.md', 'release-surface-sync']
+  ];
+
+  for (const [id, relPath, expected] of surfaces) {
+    const ok = read(projectRoot, relPath).includes(expected);
+    addCheck(
+      checks,
+      id,
+      ok ? 'fresh' : 'stale',
+      relPath,
+      ok ? `${relPath} includes ${expected}.` : `${relPath} is missing ${expected}.`,
+      { spawn: ok ? null : 'god-docs-writer' }
+    );
+  }
+
+  const packageCheckText = read(projectRoot, 'scripts/check-package-contents.js');
+  for (const required of REQUIRED_PACKAGE_GUARDS) {
+    const ok = packageCheckText.includes(required);
+    addCheck(
+      checks,
+      `package-guard-${required.replace(/[^a-z0-9]+/gi, '-')}`,
+      ok ? 'fresh' : 'stale',
+      'scripts/check-package-contents.js',
+      ok
+        ? `Package contents check requires ${required}.`
+        : `Package contents check does not require ${required}.`
+    );
+  }
+
+  const stale = checks.filter((check) => check.status !== 'fresh');
+  return {
+    status: stale.length === 0 ? 'fresh' : 'stale',
+    checks,
+    stale
+  };
+}
+
+function appendLog(projectRoot, before, after) {
+  const now = new Date().toISOString();
+  const lines = [];
+  if (fs.existsSync(path.join(projectRoot, LOG_PATH))) {
+    lines.push(read(projectRoot, LOG_PATH).replace(/\s*$/, ''));
+    lines.push('');
+  } else {
+    lines.push('# Release Surface Sync Log');
+    lines.push('');
+    lines.push('- [DECISION] This file records release-surface sync checks run by Godpowers.');
+    lines.push('');
+  }
+  lines.push(`## ${now}`);
+  lines.push('');
+  lines.push(`- [DECISION] Release surface status before apply was ${before.status}.`);
+  lines.push(`- [DECISION] Release surface status after apply is ${after.status}.`);
+  lines.push('');
+  write(projectRoot, LOG_PATH, lines.join('\n'));
+}
+
+function run(projectRoot, opts = {}) {
+  const before = detect(projectRoot);
+  const after = detect(projectRoot);
+  if (opts.log !== false) appendLog(projectRoot, before, after);
+  return {
+    before,
+    after,
+    applied: [],
+    logPath: opts.log === false ? null : LOG_PATH
+  };
+}
+
+function summary(report) {
+  return report.status === 'fresh' ? 'fresh' : `${report.stale.length} stale`;
+}
+
+module.exports = {
+  LOG_PATH,
+  REQUIRED_PACKAGE_GUARDS,
+  detect,
+  run,
+  summary
+};

package/lib/repo-surface-sync.js

@@ -0,0 +1,524 @@
+/**
+ * Repository surface sync.
+ *
+ * Detects structural drift between commands, routing, package metadata,
+ * agent contracts, workflows, recipes, extensions, and release policy docs.
+ * The helper is read-only by default. The apply path writes only safe local
+ * logs and optional missing routing stubs when explicitly requested.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { parseSimpleYaml } = require('./intent');
+const extensions = require('./extensions');
+const repoDocSync = require('./repo-doc-sync');
+const routeQualitySync = require('./route-quality-sync');
+const recipeCoverageSync = require('./recipe-coverage-sync');
+const releaseSurfaceSync = require('./release-surface-sync');
+
+const LOG_PATH = '.godpowers/surface/REPO-SURFACE-SYNC.md';
+
+const REQUIRED_PACKAGE_FILE_ENTRIES = [
+  'bin/',
+  'skills/',
+  'agents/god-*.md',
+  'templates/',
+  'references/',
+  'routing/',
+  'workflows/',
+  'schema/',
+  'lib/',
+  'extensions/',
+  'RELEASE.md',
+  'SKILL.md',
+  'AGENTS.md',
+  'CHANGELOG.md',
+  'LICENSE'
+];
+
+const REQUIRED_PACKAGE_CHECKS = [
+  'lib/feature-awareness.js',
+  'lib/repo-doc-sync.js',
+  'lib/repo-surface-sync.js',
+  'lib/route-quality-sync.js',
+  'lib/recipe-coverage-sync.js',
+  'lib/release-surface-sync.js',
+  'routing/god-export-otel.yaml'
+];
+
+function rel(projectRoot, absPath) {
+  return path.relative(projectRoot, absPath).split(path.sep).join('/');
+}
+
+function exists(projectRoot, relPath) {
+  return fs.existsSync(path.join(projectRoot, relPath));
+}
+
+function read(projectRoot, relPath) {
+  const file = path.join(projectRoot, relPath);
+  if (!fs.existsSync(file)) return '';
+  return fs.readFileSync(file, 'utf8');
+}
+
+function write(projectRoot, relPath, content) {
+  const file = path.join(projectRoot, relPath);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+}
+
+function listFiles(projectRoot, relDir, pattern) {
+  const dir = path.join(projectRoot, relDir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((name) => pattern.test(name))
+    .sort()
+    .map((name) => `${relDir}/${name}`.replace(/\\/g, '/'));
+}
+
+function readJson(projectRoot, relPath) {
+  try {
+    return JSON.parse(read(projectRoot, relPath));
+  } catch (err) {
+    return null;
+  }
+}
+
+function routeForSkill(skillPath) {
+  const base = path.basename(skillPath, '.md');
+  return `routing/${base}.yaml`;
+}
+
+function commandForSkill(skillPath) {
+  return `/${path.basename(skillPath, '.md')}`;
+}
+
+function addCheck(checks, area, id, status, relPath, message, opts = {}) {
+  checks.push({
+    area,
+    id,
+    status,
+    path: relPath,
+    message,
+    severity: opts.severity || (status === 'fresh' ? 'info' : 'warning'),
+    safeFix: opts.safeFix === true,
+    spawn: opts.spawn || null
+  });
+}
+
+function routingChecks(projectRoot) {
+  const checks = [];
+  const skills = listFiles(projectRoot, 'skills', /^god.*\.md$/);
+  const routes = listFiles(projectRoot, 'routing', /^god.*\.yaml$/);
+  const skillRoutes = new Set(skills.map(routeForSkill));
+  const routeSet = new Set(routes);
+
+  for (const skill of skills) {
+    const route = routeForSkill(skill);
+    addCheck(
+      checks,
+      'routing',
+      `route-for-${path.basename(skill, '.md')}`,
+      routeSet.has(route) ? 'fresh' : 'stale',
+      route,
+      routeSet.has(route)
+        ? `${commandForSkill(skill)} has routing metadata.`
+        : `${commandForSkill(skill)} is missing routing metadata.`,
+      { safeFix: !routeSet.has(route) }
+    );
+  }
+
+  for (const route of routes) {
+    if (!skillRoutes.has(route)) {
+      addCheck(
+        checks,
+        'routing',
+        `skill-for-${path.basename(route, '.yaml')}`,
+        'stale',
+        route,
+        `${route} has no matching skill file.`,
+        { severity: 'warning' }
+      );
+    }
+  }
+  return checks;
+}
+
+function packageChecks(projectRoot) {
+  const checks = [];
+  const pkg = readJson(projectRoot, 'package.json') || {};
+  const lock = readJson(projectRoot, 'package-lock.json');
+  const fileEntries = Array.isArray(pkg.files) ? pkg.files : [];
+
+  for (const entry of REQUIRED_PACKAGE_FILE_ENTRIES) {
+    addCheck(
+      checks,
+      'package',
+      `package-files-${entry.replace(/[^a-z0-9]+/gi, '-')}`,
+      fileEntries.includes(entry) ? 'fresh' : 'stale',
+      'package.json',
+      fileEntries.includes(entry)
+        ? `package.json includes ${entry}.`
+        : `package.json files is missing ${entry}.`
+    );
+  }
+
+  const packageCheckText = read(projectRoot, 'scripts/check-package-contents.js');
+  for (const required of REQUIRED_PACKAGE_CHECKS) {
+    addCheck(
+      checks,
+      'package',
+      `package-check-${required.replace(/[^a-z0-9]+/gi, '-')}`,
+      packageCheckText.includes(required) ? 'fresh' : 'stale',
+      'scripts/check-package-contents.js',
+      packageCheckText.includes(required)
+        ? `package contents check requires ${required}.`
+        : `package contents check does not require ${required}.`
+    );
+  }
+
+  if (lock && lock.version) {
+    addCheck(
+      checks,
+      'package',
+      'package-lock-version',
+      lock.version === pkg.version ? 'fresh' : 'stale',
+      'package-lock.json',
+      lock.version === pkg.version
+        ? 'package-lock.json version matches package.json.'
+        : `package-lock.json version ${lock.version} does not match package.json ${pkg.version}.`
+    );
+  }
+
+  return checks;
+}
+
+function parseRoute(projectRoot, routePath) {
+  try {
+    return parseSimpleYaml(read(projectRoot, routePath));
+  } catch (err) {
+    return null;
+  }
+}
+
+function agentChecks(projectRoot) {
+  const checks = [];
+  const agents = new Set(listFiles(projectRoot, 'agents', /^god.*\.md$/)
+    .map((file) => path.basename(file, '.md')));
+  const routes = listFiles(projectRoot, 'routing', /^god.*\.yaml$/);
+  const missing = new Set();
+
+  for (const route of routes) {
+    const parsed = parseRoute(projectRoot, route);
+    const execution = parsed && parsed.execution ? parsed.execution : {};
+    const spawns = [
+      ...(Array.isArray(execution.spawns) ? execution.spawns : []),
+      ...(Array.isArray(execution['secondary-spawns']) ? execution['secondary-spawns'] : []),
+      ...(Array.isArray(execution['parallel-spawns']) ? execution['parallel-spawns'] : [])
+    ].map((spawn) => (spawn && typeof spawn === 'object' && spawn.agent) ? spawn.agent : spawn);
+    for (const spawn of spawns) {
+      if (!String(spawn).startsWith('god-')) continue;
+      if (!/^god-[a-z0-9-]+$/.test(String(spawn))) continue;
+      if (!agents.has(spawn)) {
+        missing.add(`${route}:${spawn}`);
+        addCheck(
+          checks,
+          'agents',
+          `missing-agent-${spawn}`,
+          'stale',
+          route,
+          `${route} references missing agent ${spawn}.`,
+          { spawn: 'god-auditor' }
+        );
+      }
+    }
+  }
+
+  if (missing.size === 0) {
+    addCheck(checks, 'agents', 'route-spawn-targets', 'fresh',
+      'routing/', 'All routed specialist spawns resolve to agent files.');
+  }
+
+  return checks;
+}
+
+function workflowRecipeChecks(projectRoot) {
+  const checks = [];
+  const workflows = listFiles(projectRoot, 'workflows', /\.yaml$/);
+  const recipes = listFiles(projectRoot, path.join('routing', 'recipes'), /\.yaml$/);
+  const commandFlows = read(projectRoot, 'docs/command-flows.md');
+
+  for (const workflow of workflows) {
+    const text = read(projectRoot, workflow);
+    const parsed = parseSimpleYaml(text);
+    const hasMetadata = Boolean(parsed.apiVersion || parsed.name || parsed.metadata);
+    addCheck(
+      checks,
+      'workflow',
+      `workflow-metadata-${path.basename(workflow, '.yaml')}`,
+      hasMetadata ? 'fresh' : 'stale',
+      workflow,
+      hasMetadata ? `${workflow} has metadata.` : `${workflow} is missing parseable metadata.`,
+      { spawn: hasMetadata ? null : 'god-roadmap-reconciler' }
+    );
+  }
+
+  for (const recipe of recipes) {
+    const text = read(projectRoot, recipe);
+    const hasCommand = /\/god-[a-z0-9-]+/.test(text);
+    const recipeName = path.basename(recipe, '.yaml');
+    addCheck(
+      checks,
+      'workflow',
+      `recipe-command-${recipeName}`,
+      hasCommand ? 'fresh' : 'stale',
+      recipe,
+      hasCommand ? `${recipe} includes a slash-command route.` : `${recipe} has no slash-command route.`,
+      { spawn: hasCommand ? null : 'god-roadmap-reconciler' }
+    );
+  }
+
+  if (workflows.length > 0) {
+    addCheck(
+      checks,
+      'workflow',
+      'command-flows-workflows',
+      commandFlows.includes('/god-docs') && commandFlows.includes('/god-sync') ? 'fresh' : 'stale',
+      'docs/command-flows.md',
+      'docs/command-flows.md includes core docs and sync flows.',
+      { spawn: 'god-roadmap-reconciler' }
+    );
+  }
+  return checks;
+}
+
+function extensionChecks(projectRoot) {
+  const checks = [];
+  const extRoot = path.join(projectRoot, 'extensions');
+  const pkg = readJson(projectRoot, 'package.json') || {};
+  if (!fs.existsSync(extRoot)) return checks;
+  for (const entry of fs.readdirSync(extRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const packRel = `extensions/${entry.name}`;
+    const manifestRel = `${packRel}/manifest.yaml`;
+    const packageRel = `${packRel}/package.json`;
+    const manifestText = read(projectRoot, manifestRel);
+    const packPkg = readJson(projectRoot, packageRel);
+    const parsed = manifestText ? extensions.parseManifest(manifestText).manifest : null;
+    const validation = parsed ? extensions.validateManifest(parsed, pkg.version || '0.0.0') : ['missing manifest'];
+
+    addCheck(
+      checks,
+      'extensions',
+      `extension-manifest-${entry.name}`,
+      validation.length === 0 ? 'fresh' : 'stale',
+      manifestRel,
+      validation.length === 0
+        ? `${entry.name} manifest validates against current Godpowers.`
+        : `${entry.name} manifest validation failed: ${validation.join('; ')}.`,
+      { spawn: validation.length === 0 ? null : 'god-coordinator' }
+    );
+
+    if (parsed && packPkg) {
+      const sameName = parsed.metadata && parsed.metadata.name === packPkg.name;
+      const sameVersion = parsed.metadata && parsed.metadata.version === packPkg.version;
+      const sameEngine = packPkg.peerDependencies
+        && packPkg.peerDependencies.godpowers === parsed.engines.godpowers;
+      addCheck(checks, 'extensions', `extension-name-${entry.name}`,
+        sameName ? 'fresh' : 'stale', packageRel,
+        sameName ? `${entry.name} package name matches manifest.` : `${entry.name} package name does not match manifest.`,
+        { spawn: sameName ? null : 'god-coordinator' });
+      addCheck(checks, 'extensions', `extension-version-${entry.name}`,
+        sameVersion ? 'fresh' : 'stale', packageRel,
+        sameVersion ? `${entry.name} package version matches manifest.` : `${entry.name} package version does not match manifest.`,
+        { spawn: sameVersion ? null : 'god-coordinator' });
+      addCheck(checks, 'extensions', `extension-engine-${entry.name}`,
+        sameEngine ? 'fresh' : 'stale', packageRel,
+        sameEngine ? `${entry.name} peer dependency matches manifest engine.` : `${entry.name} peer dependency does not match manifest engine.`,
+        { spawn: sameEngine ? null : 'god-coordinator' });
+      for (const kind of ['skills', 'agents', 'workflows']) {
+        const provided = parsed.provides && Array.isArray(parsed.provides[kind])
+          ? parsed.provides[kind]
+          : [];
+        for (const item of provided) {
+          const ext = kind === 'workflows' ? 'yaml' : 'md';
+          const providedRel = `${packRel}/${kind}/${item}.${ext}`;
+          addCheck(checks, 'extensions', `extension-${kind}-${entry.name}-${item}`,
+            exists(projectRoot, providedRel) ? 'fresh' : 'stale',
+            providedRel,
+            exists(projectRoot, providedRel)
+              ? `${providedRel} exists.`
+              : `${providedRel} is missing.`,
+            { spawn: exists(projectRoot, providedRel) ? null : 'god-coordinator' });
+        }
+      }
+    }
+  }
+  return checks;
+}
+
+function releasePolicyChecks(projectRoot) {
+  const checks = [];
+  const docs = repoDocSync.detect(projectRoot);
+  addCheck(
+    checks,
+    'release',
+    'repo-doc-sync-fresh',
+    docs.status === 'fresh' ? 'fresh' : 'stale',
+    'docs/repo-doc-sync.md',
+    docs.status === 'fresh'
+      ? 'Repository documentation sync reports fresh.'
+      : `Repository documentation sync reports ${docs.stale.length} stale checks.`,
+    { spawn: docs.status === 'fresh' ? null : 'god-docs-writer' }
+  );
+  addCheck(
+    checks,
+    'release',
+    'release-checklist-surface-sync',
+    read(projectRoot, 'docs/RELEASE-CHECKLIST.md').includes('repo-surface-sync'),
+    'docs/RELEASE-CHECKLIST.md',
+    'Release checklist references repo-surface-sync readiness.',
+    { spawn: 'god-docs-writer' }
+  );
+  return checks.map((check) => ({
+    ...check,
+    status: check.status === true ? 'fresh' : (check.status === false ? 'stale' : check.status)
+  }));
+}
+
+function detect(projectRoot) {
+  const checks = [
+    ...routingChecks(projectRoot),
+    ...packageChecks(projectRoot),
+    ...agentChecks(projectRoot),
+    ...workflowRecipeChecks(projectRoot),
+    ...extensionChecks(projectRoot),
+    ...releasePolicyChecks(projectRoot),
+    ...routeQualitySync.detect(projectRoot).checks,
+    ...recipeCoverageSync.detect(projectRoot).checks,
+    ...releaseSurfaceSync.detect(projectRoot).checks
+  ];
+  const stale = checks.filter((check) => check.status !== 'fresh');
+  const byArea = {};
+  for (const check of checks) {
+    if (!byArea[check.area]) byArea[check.area] = { total: 0, stale: 0 };
+    byArea[check.area].total++;
+    if (check.status !== 'fresh') byArea[check.area].stale++;
+  }
+  const spawnRecommendations = [...new Set(stale.map((check) => check.spawn).filter(Boolean))]
+    .map((agent) => ({
+      agent,
+      reason: `Repo surface drift requires ${agent} judgment.`,
+      paths: [...new Set(stale.filter((check) => check.spawn === agent).map((check) => check.path))].sort()
+    }));
+  return {
+    status: stale.length === 0 ? 'fresh' : 'stale',
+    checks,
+    stale,
+    byArea,
+    spawnRecommendations
+  };
+}
+
+function routeTemplate(command) {
+  const name = command.replace(/^\//, '');
+  return [
+    'apiVersion: godpowers/v1',
+    'kind: CommandRouting',
+    'metadata:',
+    `  command: ${command}`,
+    '  description: ',
+    '  tier: 0',
+    '',
+    'prerequisites:',
+    '  required: []',
+    '',
+    'execution:',
+    '  spawns: [built-in]',
+    '  context: fresh',
+    '  writes: []',
+    '',
+    'success-path:',
+    '  next-recommended: /god-status',
+    '',
+    'failure-path:',
+    '  on-error: /god-doctor',
+    '',
+    'endoff:',
+    '  state-update: none',
+    '  events: [agent.start, agent.end]',
+    ''
+  ].join('\n').replace('description: ', `description: Route metadata for /${name}`);
+}
+
+function applySafeFixes(projectRoot, report, opts = {}) {
+  const applied = [];
+  if (!opts.fixRouting) return applied;
+  for (const check of report.stale) {
+    if (check.area !== 'routing' || !check.safeFix || !check.path.startsWith('routing/')) continue;
+    if (exists(projectRoot, check.path)) continue;
+    const command = `/${path.basename(check.path, '.yaml')}`;
+    write(projectRoot, check.path, routeTemplate(command));
+    applied.push({ path: check.path, check: check.id });
+  }
+  return applied;
+}
+
+function appendLog(projectRoot, before, after, applied) {
+  const now = new Date().toISOString();
+  const lines = [];
+  if (exists(projectRoot, LOG_PATH)) {
+    lines.push(read(projectRoot, LOG_PATH).replace(/\s*$/, ''));
+    lines.push('');
+  } else {
+    lines.push('# Repo Surface Sync Log');
+    lines.push('');
+    lines.push('- [DECISION] This file records structural repository surface sync checks run by Godpowers.');
+    lines.push('- [DECISION] Detection is read-only by default and safe fixes require explicit fix options.');
+    lines.push('');
+  }
+  lines.push(`## ${now}`);
+  lines.push('');
+  lines.push(`- [DECISION] Repo surface sync status before apply was ${before.status}.`);
+  lines.push(`- [DECISION] Repo surface sync status after apply is ${after.status}.`);
+  if (applied.length === 0) {
+    lines.push('- [DECISION] No structural repository surface files were changed.');
+  } else {
+    for (const item of applied) {
+      lines.push(`- [DECISION] Created or refreshed ${item.path} for ${item.check}.`);
+    }
+  }
+  for (const rec of after.spawnRecommendations) {
+    lines.push(`- [HYPOTHESIS] ${rec.agent} should review ${rec.paths.join(', ')}.`);
+  }
+  lines.push('');
+  write(projectRoot, LOG_PATH, lines.join('\n'));
+}
+
+function run(projectRoot, opts = {}) {
+  const before = detect(projectRoot);
+  const applied = applySafeFixes(projectRoot, before, opts);
+  const after = detect(projectRoot);
+  if (opts.log !== false) appendLog(projectRoot, before, after, applied);
+  return {
+    before,
+    after,
+    applied,
+    logPath: opts.log === false ? null : LOG_PATH
+  };
+}
+
+function summary(report) {
+  if (report.status === 'fresh') return 'fresh';
+  return `${report.stale.length} stale across ${Object.keys(report.byArea).length} areas`;
+}
+
+module.exports = {
+  LOG_PATH,
+  REQUIRED_PACKAGE_CHECKS,
+  REQUIRED_PACKAGE_FILE_ENTRIES,
+  detect,
+  run,
+  summary,
+  routeTemplate
+};