session-orchestrator 5.1.0 → 5.3.0

package/scripts/eval-session.mjs

@@ -8,7 +8,8 @@
  * Follows .claude/rules/cli-design.md:
  *   - `--json` for machine output; human-readable by default.
  *   - Data → stdout, diagnostics → stderr.
- *   - Exit codes: 0 success/match · 1 user-error/drift · 2 system error.
+ *   - Exit codes: 0 success/match · 1 user-error/drift · 2 system error ·
+ *     3 verify version-mismatch (non-standard, documented in --help).
  *
  * ## Append failures are NOT exit 0 (GitLab #969)
  *
@@ -40,6 +41,17 @@
  * Session-end Phase 3.7d remains advisory and MUST NOT gate on this exit code —
  * it catches a non-zero exit and logs a WARN (skills/session-end/SKILL.md).
  *
+ * ## A rubric change is not scoring drift (GitLab #1400)
+ *
+ * `--verify` re-scores a stored record with the CURRENT engine. When the stored
+ * `rubric_version` differs from `RUBRIC_VERSION`, the two sides answer different
+ * pre-registered check sets, so neither MATCH nor DRIFT is true: the run exits
+ * `3` with `verdict: "version-mismatch"` and re-scores nothing. Exit `0` would
+ * sell a cross-rubric comparison as a reproducibility proof; exit `1` would put
+ * a planned rubric bump in the same bucket as a forged record. Measured
+ * 2026-09-19: all 40 records in this repo's journal are `rubric-v1` and every
+ * one of them exited 1 as DRIFT under the rubric-v2 engine.
+ *
  * Usage:
  *   eval-session.mjs [--session <id>] [--json] [--no-write]
  *                    [--metrics-dir <path>] [--rubric <path>]
@@ -68,6 +80,8 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const EXIT_OK = 0;
 const EXIT_USER = 1;
 const EXIT_SYSTEM = 2;
+/** Non-standard, `--verify` only: the stored record predates the current rubric (#1400). */
+const EXIT_VERSION_MISMATCH = 3;
 
 function readPkgVersion() {
   try {
@@ -103,6 +117,9 @@ EXIT CODES
   1  user error (session not found, unknown run-id, record failed validation)
      / verify drift
   2  system error (could not append the record to the eval journal)
+  3  verify version-mismatch: the stored record was scored under a different
+     rubric than ${RUBRIC_VERSION}, so it is not re-verifiable with this engine
+     (non-standard code — neither a match nor drift)
 `;
 
 function fail(exitCode, message) {
@@ -211,6 +228,49 @@ function runVerify(runId, values) {
     fail(EXIT_USER, `--verify: run-id not found in eval journal: ${runId}`);
   }
 
+  // #1400 — check the rubric BEFORE re-scoring. A record scored under another
+  // rubric answers a different pre-registered check set, so re-running the
+  // current engine over it produces a comparison nobody asked for. A record
+  // with no `rubric_version` at all is unattributable and counts as a mismatch.
+  const storedRubric = typeof stored.rubric_version === 'string' && stored.rubric_version
+    ? stored.rubric_version
+    : null;
+  if (storedRubric !== RUBRIC_VERSION) {
+    // Deliberately NO diff of the dimensions the two rubrics share. Such a diff
+    // is technically possible but would carry almost no signal here. Measured
+    // 2026-09-19 over this repo's 40-record journal, replaying every record
+    // through `evaluateSession` + `diffDimensions`: all 40 differ on
+    // `process-safety` (its formula IS the v2 change) and all 40 gain a
+    // `present-in-fresh-only` `guard-friction`; restricted to the
+    // formula-unchanged dimensions, only 4 of 40 are byte-identical and the
+    // other 36 differ on `verification-evidence` / `gate-health` because the
+    // events they were scored from predate this journal's `events.jsonl`. So a
+    // "common dimensions" diff would re-report 90% of the journal as drift under
+    // a new name — the same misdirection in another shape (HR-101: a class that
+    // fires on ~90% of samples is a broken instrument, not a signal).
+    // Ceiling: holds while a rubric bump coincides with truncated evidence.
+    // Revisit-Trigger: the next rubric bump where every stored record's source
+    // events are still present — then a common-dimension diff carries signal.
+    if (values.json) {
+      writeStdoutLineSync(
+        JSON.stringify({
+          run_id: runId,
+          match: false,
+          verdict: 'version-mismatch',
+          stored_rubric_version: storedRubric,
+          engine_rubric_version: RUBRIC_VERSION,
+        }),
+      );
+    } else {
+      writeStdoutLineSync(
+        `VERSION-MISMATCH: ${runId} was scored under ${storedRubric ?? '(no rubric_version)'}; ` +
+          `this engine scores ${RUBRIC_VERSION} — not re-verifiable with this engine ` +
+          '(not drift, not a match).',
+      );
+    }
+    process.exit(EXIT_VERSION_MISMATCH);
+  }
+
   let fresh;
   try {
     fresh = evaluateSession({
@@ -236,7 +296,9 @@ function runVerify(runId, values) {
 
   if (diffs.length === 0) {
     if (values.json) {
-      writeStdoutLineSync(JSON.stringify({ run_id: runId, match: true, dimensions: fresh.dimensions.length }));
+      writeStdoutLineSync(
+        JSON.stringify({ run_id: runId, match: true, verdict: 'match', dimensions: fresh.dimensions.length }),
+      );
     } else {
       writeStdoutLineSync(`MATCH: ${runId} re-evaluates identically across ${fresh.dimensions.length} dimension(s).`);
     }
@@ -244,7 +306,7 @@ function runVerify(runId, values) {
   }
 
   if (values.json) {
-    writeStdoutLineSync(JSON.stringify({ run_id: runId, match: false, diffs }));
+    writeStdoutLineSync(JSON.stringify({ run_id: runId, match: false, verdict: 'drift', diffs }));
   } else {
     const out = [`DRIFT: ${runId} re-evaluation differs from the stored record:`];
     for (const d of diffs) {

package/scripts/export-hw-learnings.mjs

@@ -63,6 +63,7 @@ import { parseSessionConfig } from './lib/config.mjs';
 import { createSecretValueMasker } from './lib/secret-masker.mjs';
 import { stableHostname, readHostAliases } from './lib/host-identity.mjs';
 import { emitEvent, sessionAttribution } from './lib/events.mjs';
+import { isMainModule } from './lib/is-main-module.mjs';
 
 // Vault-relative default write target (Epic #774 — docs Public-Split removed
 // the prior in-repo generated telemetry doc in favor of the private Meta-Vault).
@@ -724,7 +725,7 @@ export async function exportHwLearnings(opts) {
 }
 
 // Run as CLI when invoked directly
-const isMain = import.meta.url === `file://${process.argv[1]}`;
+const isMain =isMainModule(import.meta.url);
 if (isMain) {
   const opts = parseArgs(process.argv.slice(2));
 

package/scripts/express-path.mjs

@@ -281,7 +281,7 @@ async function main() {
 
   // The banner the coordinator echoes into the transcript — `/go` and
   // session-plan's Express Path Short-Circuit both key off this EXACT line
-  // (`commands/go.md` § Express Path Detection), so it is written verbatim,
+  // (`skills/go/SKILL.md` § Express Path Detection), so it is written verbatim,
   // without the `express-path:` diagnostic prefix. Still stderr: stdout belongs
   // to the verdict.
   if (verdict.activated) {

package/scripts/gc-stale-worktrees.mjs

@@ -26,6 +26,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { validateWorkspacePath } from './lib/worktree/lifecycle.mjs';
+import { isMainModule } from './lib/is-main-module.mjs';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -658,7 +659,7 @@ EXIT CODES
 // CLI guard — prevents process.exit during test-time imports (#368)
 // ---------------------------------------------------------------------------
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (isMainModule(import.meta.url)) {
   main().catch((err) => {
     process.stderr.write(`gc-stale-worktrees: unexpected error: ${err?.stack ?? err}\n`);
     process.exit(2);

package/scripts/generate-agents-skills.mjs

@@ -12,10 +12,11 @@
  * This generator writes two artefacts, both DERIVED and never hand-edited:
  *
  *   1. `AGENTS.md`               — a BYTE-IDENTICAL copy of `CLAUDE.md`.
- *   2. `.agents/skills/<name>/SKILL.md` — a portable mirror of each
- *      `skills/<name>/SKILL.md`, carrying ONLY agentskills.io-spec-legal
+ *   2. `.agents/skills/<name>/SKILL.md` — a portable mirror of each skill and
+ *      command (commands own overlapping names), carrying ONLY spec-legal
  *      frontmatter plus a pointer body (progressive disclosure — the mirror
- *      never duplicates the canonical instructions).
+ *      never duplicates the canonical instructions). Native Codex invocation
+ *      policy travels in an adjacent `agents/openai.yaml` when applicable.
  *
  * ## Why a generated copy and NOT a symlink (measured, not preferred)
  *
@@ -53,6 +54,9 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 import yaml from 'js-yaml';
+import { isUserInvocableValue } from './lib/user-invocable-skills.mjs';
+
+const POLICY_MARKER = '# Generated by scripts/generate-agents-skills.mjs; do not edit.\n';
 
 /**
  * The complete set of SKILL.md frontmatter keys agentskills.io permits outside
@@ -159,29 +163,40 @@ export function toPortableFrontmatter(source, skillName) {
  *
  * @param {string} skillName
  * @param {Record<string, unknown>} portableFm
+ * @param {string} [canonical] plugin-relative source path; defaults to the skill
  * @returns {string}
  */
-export function renderMirror(skillName, portableFm) {
+export function renderMirror(skillName, portableFm, canonical = `skills/${skillName}/SKILL.md`) {
   const front = yaml.dump(portableFm, { lineWidth: -1, noRefs: true, quotingType: '"' });
-  const canonical = `skills/${skillName}/SKILL.md`;
-  return [
+  const command = canonical.startsWith('commands/');
+  const lines = [
     '---',
     front.trimEnd(),
     '---',
     '',
     `# ${skillName}`,
     '',
-    `> **Portable mirror — generated, do not edit.** The canonical skill body lives at`,
+    `> **Portable mirror — generated, do not edit.** The canonical workflow lives at`,
     `> [\`${canonical}\`](../../../${canonical}); read that file for the full instructions.`,
     `> This mirror carries only agentskills.io-spec-legal frontmatter so harnesses that`,
     `> discover skills under \`.agents/skills/\` can find and route to the skill.`,
     '>',
     '> Regenerate with `node scripts/generate-agents-skills.mjs`.',
     '',
-  ].join('\n');
+    'Read the linked document in full and follow its complete workflow, including prechecks and stop conditions. Resolve its link relative to this SKILL.md, not the project working directory. The plugin root is three directories above this file. Resolve package paths such as `skills/` and `scripts/` from that root and relative links in the canonical document from its own directory. Keep the user’s project as the target of project operations.',
+  ];
+  if (command || isUserInvocableValue(portableFm.metadata?.['user-invocable'])) lines.push(
+    '',
+    '`$ARGUMENTS` means the trailing user input after the selected command skill, or an empty string when absent. Preserve flags, quoted text, and Unicode as data. Do not perform global substitution in the command document, shell expansion on the argument string, or execution of that string as shell code. Pass command arguments through structured tool parameters or safely quoted individual arguments.',
+  );
+  if (command) lines.push(
+    '',
+    'Read the full command before invoking an internal skill. An instruction to invoke a skill (including `session-orchestrator:<name>` or the `Skill` tool) means read and follow the canonical `skills/<name>/SKILL.md` beneath the plugin root. Do not redispatch the public command adapter: a same-named command and internal skill are distinct documents, and redispatch would recurse.',
+  );
+  return [...lines, ''].join('\n');
 }
 
-/** Parse a SKILL.md's YAML frontmatter block; returns `{}` when absent/unparseable. */
+/** Parse a source's YAML frontmatter block; returns null when absent/unparseable. */
 function readFrontmatter(absPath) {
   const content = readFileSync(absPath, 'utf8');
   const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
@@ -205,6 +220,44 @@ export function listSourceSkills(pluginRoot) {
     .sort();
 }
 
+/** Union of canonical skills and commands, preserving command precedence. */
+function listSourceEntries(pluginRoot) {
+  const sources = new Map(listSourceSkills(pluginRoot).map((name) => [name, `skills/${name}/SKILL.md`]));
+  const commands = path.join(pluginRoot, 'commands');
+  if (existsSync(commands) && statSync(commands).isDirectory()) {
+    for (const entry of readdirSync(commands, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith('.md') || /^[._]/.test(entry.name)) continue;
+      sources.set(entry.name.slice(0, -3), `commands/${entry.name}`);
+    }
+  }
+  return sources;
+}
+
+/** Match Codex policy precedence: command, native skill override, public skill. */
+function invocationPolicy(pluginRoot, name, canonical, fm) {
+  if (!canonical.startsWith('commands/')) {
+    const nativePath = path.join(pluginRoot, 'skills', name, 'agents', 'openai.yaml');
+    if (existsSync(nativePath)) {
+      const native = yaml.load(readFileSync(nativePath, 'utf8'), { schema: yaml.CORE_SCHEMA });
+      const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+      if (!isRecord(native) || (Object.hasOwn(native, 'policy') && !isRecord(native.policy))) {
+        throw new Error(`${nativePath}: native skill metadata and policy must be mappings`);
+      }
+      if (native.policy && Object.hasOwn(native.policy, 'allow_implicit_invocation')) {
+        if (typeof native.policy.allow_implicit_invocation !== 'boolean') {
+          throw new Error(`${nativePath}: policy.allow_implicit_invocation must be a boolean`);
+        }
+        return native.policy.allow_implicit_invocation;
+      }
+    }
+    if (!isUserInvocableValue(fm['user-invocable'], canonical)) return undefined;
+  }
+  if (Object.hasOwn(fm, 'disable-model-invocation') && typeof fm['disable-model-invocation'] !== 'boolean') {
+    throw new Error(`${canonical}: disable-model-invocation must be a boolean`);
+  }
+  return fm['disable-model-invocation'] !== true;
+}
+
 /**
  * Is `AGENTS.md` already an alias of `CLAUDE.md` by construction?
  *
@@ -268,34 +321,53 @@ export function generateAgentsSurface({ pluginRoot, check = false }) {
 
   // --- Artefact 2: .agents/skills/<name>/SKILL.md ---------------------------
   const mirrorRoot = path.join(pluginRoot, '.agents', 'skills');
-  const skills = listSourceSkills(pluginRoot);
+  const sources = listSourceEntries(pluginRoot);
+  const skills = [...sources.keys()].sort();
   let files = 0;
   let bytes = 0;
 
   for (const name of skills) {
-    const src = path.join(pluginRoot, 'skills', name, 'SKILL.md');
+    const canonical = sources.get(name);
+    const src = path.join(pluginRoot, canonical);
     const fm = readFrontmatter(src);
     if (fm === null) {
-      warnings.push(`${name}: SKILL.md has no parseable frontmatter — skipped`);
+      warnings.push(`${canonical}: has no parseable frontmatter — skipped`);
       continue;
     }
     const { fm: portable, warnings: w } = toPortableFrontmatter(fm, name);
     warnings.push(...w);
-    const rendered = renderMirror(name, portable);
-    const dest = path.join(mirrorRoot, name, 'SKILL.md');
-    files += 1;
-    bytes += Buffer.byteLength(rendered, 'utf8');
-
-    const current = existsSync(dest) ? readFileSync(dest, 'utf8') : null;
-    if (current === rendered) continue;
-    if (check) {
-      drift.push(current === null
-        ? `.agents/skills/${name}/SKILL.md is missing`
-        : `.agents/skills/${name}/SKILL.md is stale`);
-    } else {
-      mkdirSync(path.dirname(dest), { recursive: true });
-      writeFileSync(dest, rendered, 'utf8');
-      written.push(`.agents/skills/${name}/SKILL.md`);
+    const artifacts = new Map([['SKILL.md', renderMirror(name, portable, canonical)]]);
+    const policy = invocationPolicy(pluginRoot, name, canonical, fm);
+    const policyPath = path.join(mirrorRoot, name, 'agents', 'openai.yaml');
+    if (policy !== undefined) {
+      artifacts.set('agents/openai.yaml', POLICY_MARKER + yaml.dump({
+        interface: { display_name: name },
+        policy: { allow_implicit_invocation: policy },
+      }, { lineWidth: -1, noRefs: true }));
+    } else if (existsSync(policyPath) && readFileSync(policyPath, 'utf8').startsWith(POLICY_MARKER)) {
+      if (check) drift.push(`.agents/skills/${name}/agents/openai.yaml is obsolete`);
+      else {
+        rmSync(policyPath);
+        written.push(`removed .agents/skills/${name}/agents/openai.yaml`);
+      }
+    }
+    for (const [file, rendered] of artifacts) {
+      const relative = `.agents/skills/${name}/${file}`;
+      const dest = path.join(mirrorRoot, name, file);
+      files += 1;
+      bytes += Buffer.byteLength(rendered, 'utf8');
+      const current = existsSync(dest) ? readFileSync(dest, 'utf8') : null;
+      if (file === 'agents/openai.yaml' && current !== null && !current.startsWith(POLICY_MARKER)) {
+        drift.push(`${relative} conflicts with an unrelated native policy — retained`);
+        continue;
+      }
+      if (current === rendered) continue;
+      if (check) drift.push(`${relative} is ${current === null ? 'missing' : 'stale'}`);
+      else {
+        mkdirSync(path.dirname(dest), { recursive: true });
+        writeFileSync(dest, rendered, 'utf8');
+        written.push(relative);
+      }
     }
   }
 
@@ -306,7 +378,7 @@ export function generateAgentsSurface({ pluginRoot, check = false }) {
     for (const entry of readdirSync(mirrorRoot, { withFileTypes: true })) {
       if (!entry.isDirectory() || known.has(entry.name)) continue;
       if (check) {
-        drift.push(`.agents/skills/${entry.name}/ is an orphan (no skills/${entry.name}/SKILL.md)`);
+        drift.push(`.agents/skills/${entry.name}/ is an orphan (no skill or command source)`);
       } else {
         rmSync(path.join(mirrorRoot, entry.name), { recursive: true, force: true });
         written.push(`removed .agents/skills/${entry.name}/`);
@@ -356,8 +428,9 @@ function main(argv) {
     }
   } else {
     for (const w of result.warnings) process.stderr.write(`  WARN: agents-surface: ${w}\n`);
+    for (const d of result.drift) process.stderr.write(`✗ agents-surface: ${d}\n`);
     process.stdout.write(
-      `agents-surface: ${result.written.length} file(s) written, ${result.files} skill mirror(s), ${result.bytes} bytes\n`,
+      `agents-surface: ${result.written.length} file(s) written, ${result.files} portable artefact(s), ${result.bytes} bytes\n`,
     );
   }
   return result.ok ? 0 : 1;

package/scripts/generate-codex-skills.mjs

@@ -9,6 +9,7 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import yaml from 'js-yaml';
 import { toPortableFrontmatter } from './generate-agents-skills.mjs';
+import { isUserInvocableValue } from './lib/user-invocable-skills.mjs';
 
 const OUTPUT = '.codex-plugin/skills';
 const MARKER = 'Generated by scripts/generate-codex-skills.mjs; do not edit.';
@@ -26,8 +27,19 @@ function validateFrontmatter(fm, name, path) {
   if (typeof fm.description !== 'string' || !fm.description.trim() || fm.description.trim().length > 1024) {
     fail('description must be a non-empty string of at most 1024 characters');
   }
-  for (const key of ['disable-model-invocation', 'user-invocable']) {
-    if (Object.hasOwn(fm, key) && typeof fm[key] !== 'boolean') fail(`${key} must be a boolean`);
+  if (Object.hasOwn(fm, 'disable-model-invocation') && typeof fm['disable-model-invocation'] !== 'boolean') {
+    fail('disable-model-invocation must be a boolean');
+  }
+  // `user-invocable` is deliberately NOT a hard fail on a non-boolean: a quoted
+  // or cased value (`"true"`, `True`) used to crash this generator while the
+  // Cursor and Pi generators emitted a wrapper for it and the counters ignored
+  // it — four readings of one key. `isUserInvocableValue` is now the single
+  // normaliser; a value it cannot read as `true` demotes the skill (with its own
+  // WARN for the truthy-looking cases) instead of stopping the build.
+  if (Object.hasOwn(fm, 'user-invocable')
+    && typeof fm['user-invocable'] !== 'boolean'
+    && typeof fm['user-invocable'] !== 'string') {
+    fail('user-invocable must be a boolean (or the string form `"true"`/`"false"`)');
   }
   for (const key of ['argument-hint', 'license', 'compatibility']) {
     if (Object.hasOwn(fm, key) && typeof fm[key] !== 'string') fail(`${key} must be a string`);
@@ -42,6 +54,19 @@ function validateFrontmatter(fm, name, path) {
   }
 }
 
+/**
+ * The repo-wide marker for "operator-facing slash command" — delegated to
+ * `isUserInvocableValue`, the ONE normaliser, so this generator, the Cursor and
+ * Pi generators and the counters cannot disagree about a quoted or cased value.
+ *
+ * @param {Record<string, unknown>} fm
+ * @param {string} [path] named in the shared WARN when a truthy-looking value is demoted
+ * @returns {boolean}
+ */
+function isUserInvocable(fm, path) {
+  return isUserInvocableValue(fm?.['user-invocable'], path);
+}
+
 /** Existing native policy is meaningful; Claude's user-invocable flag is not a substitute. */
 function readNativePolicy(root, name) {
   const path = `skills/${name}/agents/openai.yaml`;
@@ -80,7 +105,14 @@ function readSources(root) {
       try { fm = yaml.load(match[1], { schema: yaml.CORE_SCHEMA }); }
       catch (error) { throw new Error(`${path}: invalid YAML: ${error.message}`, { cause: error }); }
       validateFrontmatter(fm, name, path);
-      sources.push({ name, path, command, fm, policy: command ? fm['disable-model-invocation'] !== true : readNativePolicy(root, name) });
+      // Policy precedence for a skill: a native `agents/openai.yaml` wins; else
+      // an explicitly user-invocable skill (a slash command that used to be a
+      // `commands/*.md` file) derives it from `disable-model-invocation` exactly
+      // as command sources do; a library skill emits no policy.
+      const policy = command
+        ? fm['disable-model-invocation'] !== true
+        : (readNativePolicy(root, name) ?? (isUserInvocable(fm, path) ? fm['disable-model-invocation'] !== true : undefined));
+      sources.push({ name, path, command, fm, policy });
     }
   }
   return sources;
@@ -128,9 +160,21 @@ function renderSkill(source, warnings) {
     '',
     'Resolve this link relative to this SKILL.md, not the project working directory. The plugin root is three directories above this file. Resolve package paths such as `skills/` and `scripts/` from that root; resolve relative links inside the canonical document from its own directory. Keep the user’s project as the target of project operations.',
   ];
-  if (source.command) lines.push(
+  // `$ARGUMENTS` semantics belong to every OPERATOR-FACING document — a
+  // `commands/*.md`, and equally a skill that declares `user-invocable: true`
+  // and references `$ARGUMENTS` in its own body. Gating them on `source.command`
+  // alone silently dropped the argument-handling contract from every command
+  // body that was folded into its same-named skill.
+  if (source.command || isUserInvocable(source.fm)) lines.push(
     '',
     '`$ARGUMENTS` means the trailing user input after the selected command skill, or an empty string when absent. Preserve flags, quoted text, and Unicode as data. Do not perform global substitution in the command document, shell expansion on the argument string, or execution of that string as shell code. When the workflow needs a command, pass its arguments through structured tool parameters or safely quoted individual arguments.',
+  );
+  // The redispatch warning is only TRUE for a command source: it exists because
+  // a same-named command and internal skill are two distinct documents. A
+  // user-invocable SKILL is already the canonical document, so telling it not to
+  // redispatch "the public command adapter" would describe a file that does not
+  // exist.
+  if (source.command) lines.push(
     '',
     'Read the full command before invoking an internal skill. An instruction to invoke a skill (including `session-orchestrator:<name>` or the `Skill` tool) means read and follow the canonical `skills/<name>/SKILL.md` beneath the plugin root. Do not redispatch the public command adapter: a same-named command and internal skill are distinct documents, and redispatch would recurse.',
   );