@joenandez/academy 0.4.0-rc.1

package/conformance/envelope.test.mjs

@@ -0,0 +1,185 @@
+// The envelope, swept across every published command.
+//
+//   success   stdout, exit 0   { contract_version, ok: true,  command, ...payload }
+//   failure   stderr, exit 1   { contract_version, ok: false, command, error }
+//
+// Exit status is 0 if and only if `ok` is true. The table is checked against
+// the command list `doctor` publishes, so a build that publishes a command this
+// suite has no case for fails here rather than going unchecked.
+
+import assert from 'node:assert/strict';
+import { symlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  academy,
+  assertFailure,
+  assertSuccess,
+  createHost,
+  hireAgent,
+  publishedCommands,
+} from './harness.mjs';
+
+function agentHost() {
+  const host = createHost();
+  hireAgent(host, 'kai');
+  return host;
+}
+
+function archivedHost() {
+  const host = agentHost();
+  assertSuccess(academy(host, ['archive', 'kai', '--json']), 'archive');
+  return host;
+}
+
+// An agents root that resolves outside itself — the one state that fails every
+// command reading the root, and so the failure case for the two that address no
+// agent and reject no option.
+function escapedHost() {
+  const host = createHost();
+  symlinkSync(host.outside, host.agentsRoot);
+  return host;
+}
+
+function specHost() {
+  const host = createHost();
+  const body = { name: 'kai', role: 'conformance subject', objective: 'exist' };
+  writeFileSync(join(host.root, 'spec.json'), JSON.stringify(body));
+  return host;
+}
+
+// `hire` without --spec execs into an interactive session with inherited stdio
+// and can never print an envelope, so the headless form is the one under test.
+const SPEC = (host) => join(host.root, 'spec.json');
+
+const CASES = {
+  doctor: [createHost, () => ['doctor'], escapedHost, () => ['doctor'], 'unsafe_agent_path'],
+  list: [createHost, () => ['list'], escapedHost, () => ['list'], 'unsafe_agent_path'],
+  inspect: [
+    agentHost,
+    () => ['inspect', 'kai'],
+    createHost,
+    () => ['inspect', 'ghost'],
+    'agent_not_found',
+  ],
+  tokens: [
+    agentHost,
+    () => ['tokens', 'kai'],
+    createHost,
+    () => ['tokens', 'ghost'],
+    'agent_not_found',
+  ],
+  budget: [
+    agentHost,
+    () => ['budget', 'kai'],
+    createHost,
+    () => ['budget', 'ghost'],
+    'agent_not_found',
+  ],
+  sessions: [
+    createHost,
+    () => ['sessions'],
+    createHost,
+    () => ['sessions', '--nope'],
+    'invalid_spec',
+  ],
+  events: [
+    createHost,
+    () => ['events', '--since', '0'],
+    createHost,
+    () => ['events', '--since', '99999'],
+    'replay_unavailable',
+  ],
+  create: [createHost, () => ['create', 'kai'], agentHost, () => ['create', 'kai'], 'agent_exists'],
+  hire: [
+    specHost,
+    (h) => ['hire', '--spec', SPEC(h)],
+    createHost,
+    (h) => ['hire', '--spec', SPEC(h)],
+    'invalid_spec',
+  ],
+  rename: [
+    agentHost,
+    () => ['rename', 'kai', 'nova'],
+    createHost,
+    () => ['rename', 'ghost', 'nova'],
+    'agent_not_found',
+  ],
+  archive: [
+    agentHost,
+    () => ['archive', 'kai'],
+    createHost,
+    () => ['archive', 'ghost'],
+    'agent_not_found',
+  ],
+  unarchive: [
+    archivedHost,
+    () => ['unarchive', 'kai'],
+    createHost,
+    () => ['unarchive', 'ghost'],
+    'agent_not_found',
+  ],
+  delete: [
+    agentHost,
+    () => ['delete', 'kai'],
+    createHost,
+    () => ['delete', 'ghost'],
+    'agent_not_found',
+  ],
+  migrate: [createHost, () => ['migrate'], createHost, () => ['migrate', '--nope'], 'invalid_spec'],
+};
+
+test('every published command has a success case and a failure case', () => {
+  const published = publishedCommands(createHost());
+
+  assert.deepEqual([...published].sort(), Object.keys(CASES).sort());
+});
+
+for (const [command, [okHost, okArgs, failHost, failArgs, code]] of Object.entries(CASES)) {
+  test(`${command} answers success in the envelope with exit 0`, () => {
+    const host = okHost();
+
+    const result = academy(host, [...okArgs(host), '--json']);
+
+    assertSuccess(result, command);
+    assert.equal(result.status, 0);
+    assert.equal(result.stderr, '');
+  });
+
+  test(`${command} answers failure in the envelope with a non-zero exit`, () => {
+    const host = failHost();
+
+    const result = academy(host, [...failArgs(host), '--json']);
+
+    assertFailure(result, command, code);
+    assert.notEqual(result.status, 0);
+    assert.equal(result.stdout, '');
+  });
+}
+
+// The one success that carries a false flag in its payload. The exit rule
+// follows `ok`, never the payload, so a client must not read a budget breach as
+// a failed command.
+test('a payload reporting a breach is still ok:true and exit 0', () => {
+  const host = agentHost();
+  writeFileSync(join(host.agentsRoot, 'kai', 'knowledge.md'), 'over the cap. '.repeat(4000));
+
+  const result = academy(host, ['budget', 'kai', '--json']);
+
+  const payload = assertSuccess(result, 'budget');
+  assert.equal(result.status, 0);
+  assert.equal(payload.withinBudget, false);
+});
+
+// The health channel is not the error channel: a degraded component is reported
+// beside an ok:true answer, and the exit rule still follows `ok`.
+test('doctor reporting health errors is still ok:true and exit 0', () => {
+  const host = agentHost();
+  writeFileSync(join(host.agentsRoot, 'kai', 'agent.yaml'), 'name: kai\nruntime: mainframe\n');
+
+  const result = academy(host, ['doctor', '--json']);
+
+  const payload = assertSuccess(result, 'doctor');
+  assert.equal(result.status, 0);
+  assert.deepEqual(payload.errors, [{ code: 'invalid_runtime_agents', count: 1 }]);
+});

package/conformance/error-codes.test.mjs

@@ -0,0 +1,125 @@
+// The published error codes, closed at contract_version 1.
+//
+// Fifteen codes, one invocation each. A client may switch on `error.code`, so
+// each row proves the code string a build actually emits and that the exit
+// status is non-zero. A build that answers a different code, or answers the
+// right code with exit 0, is not conforming.
+
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+import { academy, assertFailure, createHost, hireAgent } from './harness.mjs';
+
+const PUBLISHED_ERROR_CODES = [
+  'agent_not_found',
+  'unsafe_agent_path',
+  'not_academy_owned',
+  'invalid_name',
+  'agent_exists',
+  'agent_archived',
+  'replay_unavailable',
+  'log_corrupt',
+  'invalid_runtime',
+  'invalid_spec',
+  'runtime_unavailable',
+  'lock_timeout',
+  'internal_error',
+  'unschedule_failed',
+  'unschedule_failed_restore_blocked',
+];
+
+function marker(host, name) {
+  return join(host.agentsRoot, name, '.academy-agent.json');
+}
+
+function spec(host, body) {
+  const path = join(host.root, 'spec.json');
+  writeFileSync(path, typeof body === 'string' ? body : JSON.stringify(body));
+  return path;
+}
+
+// One row per code: a host, an invocation, and the command that answers it.
+// Each returns { command, args } and may prepare the host first.
+const INVOCATIONS = {
+  agent_not_found: () => ({ command: 'inspect', args: ['inspect', 'ghost'] }),
+  invalid_name: () => ({ command: 'inspect', args: ['inspect', 'Not A Name'] }),
+  agent_exists: (host) => {
+    hireAgent(host, 'kai');
+    return { command: 'create', args: ['create', 'kai'] };
+  },
+  agent_archived: (host) => {
+    hireAgent(host, 'kai');
+    academy(host, ['archive', 'kai', '--json']);
+    return { command: 'inspect', args: ['inspect', 'kai'] };
+  },
+  unsafe_agent_path: (host) => {
+    symlinkSync(host.outside, host.agentsRoot);
+    return { command: 'list', args: ['list'] };
+  },
+  not_academy_owned: (host) => {
+    hireAgent(host, 'kai');
+    rmSync(marker(host, 'kai'));
+    return { command: 'rename', args: ['rename', 'kai', 'nova'] };
+  },
+  invalid_runtime: (host) => {
+    hireAgent(host, 'kai');
+    writeFileSync(join(host.agentsRoot, 'kai', 'agent.yaml'), 'name: kai\nruntime: mainframe\n');
+    return { command: 'inspect', args: ['inspect', 'kai'] };
+  },
+  invalid_spec: (host) => ({ command: 'hire', args: ['hire', '--spec', spec(host, '{ not json')] }),
+  replay_unavailable: () => ({ command: 'events', args: ['events', '--since', '999999'] }),
+  log_corrupt: (host) => {
+    writeFileSync(host.eventLog, 'this line is not a record\n');
+    return { command: 'create', args: ['create', 'kai'] };
+  },
+  runtime_unavailable: () => ({ command: 'create', args: ['create', 'kai'] }),
+  lock_timeout: (host) => {
+    hireAgent(host, 'kai');
+    mkdirSync(join(host.agentsRoot, '.kai.lifecycle.lock'));
+    return { command: 'delete', args: ['delete', 'kai'] };
+  },
+  internal_error: (host) => {
+    hireAgent(host, 'kai');
+    rmSync(join(host.agentsRoot, 'kai', 'notes.md'));
+    mkdirSync(join(host.agentsRoot, 'kai', 'notes.md'));
+    return { command: 'budget', args: ['budget', 'kai'] };
+  },
+  unschedule_failed: (host) => {
+    hireAgent(host, 'kai');
+    return { command: 'delete', args: ['delete', 'kai'] };
+  },
+  unschedule_failed_restore_blocked: (host) => {
+    hireAgent(host, 'kai');
+    return { command: 'delete', args: ['delete', 'kai'] };
+  },
+};
+
+// The host each code needs. `runtime_unavailable` needs a PATH with no
+// scheduler; the two unschedule codes need a scheduler that fails to remove a
+// job, and the second needs one that refills the slot while it fails.
+const HOSTS = {
+  runtime_unavailable: { scheduler: 'missing' },
+  unschedule_failed: { scheduler: 'unscheduleFails' },
+  unschedule_failed_restore_blocked: { scheduler: 'unscheduleFailsAndRefillsTheSlot' },
+};
+
+test('the published error-code table is closed at fifteen codes', () => {
+  assert.deepEqual(Object.keys(INVOCATIONS).sort(), [...PUBLISHED_ERROR_CODES].sort());
+  assert.equal(PUBLISHED_ERROR_CODES.length, 15);
+});
+
+for (const code of PUBLISHED_ERROR_CODES) {
+  test(`${code} is reachable and answered in the envelope`, () => {
+    const host = createHost(HOSTS[code]);
+    const { command, args } = INVOCATIONS[code](host);
+
+    const result = academy(host, [...args, '--json']);
+
+    const envelope = assertFailure(result, command, code);
+    assert.notEqual(result.status, 0);
+    assert.equal(typeof envelope.error.message, 'string');
+    assert.notEqual(envelope.error.message, '');
+    assert.equal(result.stdout, '');
+  });
+}

package/conformance/harness.mjs

@@ -0,0 +1,180 @@
+// Academy client conformance suite — test harness.
+//
+// This suite is for authors of clients that drive Academy. It treats Academy as
+// a black box: it never imports Academy source, and every assertion is made
+// against the response envelope a client actually parses.
+//
+// Point it at any Academy build with ACADEMY_BIN. Unset, it drives the
+// `bin/academy` beside this directory.
+//
+//   ACADEMY_BIN=/usr/local/bin/academy node --test conformance/*.test.mjs
+//
+// SAFETY: every host below is built from an empty environment. HOME and
+// AGENTS_ROOT are fresh temporary directories, so the suite can drive the whole
+// lifecycle — including delete, archive, rename and migrate — with no way to
+// reach the agents on the machine running it. Nothing is inherited: an
+// AGENTS_ROOT or HOME already exported into your shell is not passed to the
+// binary under test.
+
+import { chmodSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** The build under test. */
+const ACADEMY_BIN = process.env.ACADEMY_BIN
+  ? resolve(process.env.ACADEMY_BIN)
+  : fileURLToPath(new URL('../bin/academy', import.meta.url));
+
+/** The contract version this suite was written against. */
+const CONTRACT_VERSION = 1;
+
+// Academy registers each agent's nightly consolidation job through a scheduler
+// it resolves from PATH as `helm-tasks`, and it launches Claude Code as
+// `claude`. Neither is part of the published response contract, and a client
+// author must not need either installed to check conformance, so each host gets
+// its own stubs. The scheduler stub is also how the suite reaches the two
+// unschedule failure codes, which no other input can produce.
+const SCHEDULER_STUBS = {
+  ok: '#!/bin/sh\nexit 0\n',
+  unscheduleFails: schedulerStub(false),
+  unscheduleFailsAndRefillsTheSlot: schedulerStub(true),
+};
+
+function schedulerStub(refillSlot) {
+  return [
+    '#!/bin/sh',
+    'action="$1"',
+    'dir=""',
+    'while [ "$#" -gt 0 ]; do',
+    '  case "$1" in --cwd) dir="$2" ;; esac',
+    '  shift',
+    'done',
+    'if [ "$action" = "delete" ]; then',
+    refillSlot ? '  mkdir -p "$dir"' : '  :',
+    '  exit 3',
+    'fi',
+    'exit 0',
+  ].join('\n');
+}
+
+const RUNTIME_STUB = '#!/bin/sh\nexit 0\n';
+
+function writeExecutable(path, body) {
+  writeFileSync(path, body);
+  chmodSync(path, 0o755);
+}
+
+/**
+ * A throwaway Academy installation target: its own HOME, its own AGENTS_ROOT,
+ * its own PATH. `scheduler: 'missing'` installs no scheduler stub, which is how
+ * a host without the scheduler binary is reached.
+ */
+export function createHost({ scheduler = 'ok' } = {}) {
+  const root = mkdtempSync(join(tmpdir(), 'academy-conformance-'));
+  const host = {
+    root,
+    home: join(root, 'home'),
+    agentsRoot: join(root, 'agents'),
+    binDir: join(root, 'bin'),
+    outside: join(root, 'outside'),
+    eventLog: join(root, 'events.jsonl'),
+  };
+  for (const dir of [host.home, host.binDir, host.outside]) mkdirSync(dir, { recursive: true });
+  writeExecutable(join(host.binDir, 'claude'), RUNTIME_STUB);
+  if (scheduler !== 'missing') {
+    writeExecutable(join(host.binDir, 'helm-tasks'), SCHEDULER_STUBS[scheduler]);
+  }
+  host.env = hostEnv(host);
+  return host;
+}
+
+// Built from nothing, not from process.env. PATH carries the stub directory,
+// the running node (Academy's launcher is `#!/usr/bin/env node`), and the system
+// directories that hold `git`, which `doctor` uses to describe a checkout.
+function hostEnv(host) {
+  return {
+    HOME: host.home,
+    AGENTS_ROOT: host.agentsRoot,
+    PATH: [host.binDir, dirname(process.execPath), '/usr/bin', '/bin'].join(':'),
+  };
+}
+
+/** Run the binary under test. Returns the raw result a shell would see. */
+export function academy(host, args, env = {}) {
+  const result = spawnSync(ACADEMY_BIN, args, {
+    cwd: host.root,
+    encoding: 'utf8',
+    env: { ...host.env, ...env },
+  });
+  if (result.error) throw result.error;
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// The envelope
+//
+//   success   stdout, exit 0   { contract_version, ok: true,  command, ...payload }
+//   failure   stderr, exit 1   { contract_version, ok: false, command,
+//                                error: { code, message, ...context } }
+//
+// Exit status is 0 if and only if `ok` is true. `doctor` is the one command
+// whose failure envelope also carries its payload.
+// ─────────────────────────────────────────────────────────────────────────────
+
+function parseEnvelope(text, where, result) {
+  if (text.trim() === '') {
+    throw new Error(`expected a JSON envelope on ${where}, got nothing.\n${describe(result)}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`expected a JSON envelope on ${where}: ${error.message}\n${describe(result)}`);
+  }
+}
+
+function describe(result) {
+  return `  exit   ${result.status}\n  stdout ${result.stdout.trim()}\n  stderr ${result.stderr.trim()}`;
+}
+
+function assertEqual(actual, expected, what, result) {
+  if (actual === expected) return;
+  throw new Error(
+    `expected ${what} to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}\n${describe(result)}`,
+  );
+}
+
+/** Assert a success envelope on stdout with exit 0, and return its payload. */
+export function assertSuccess(result, command) {
+  assertEqual(result.status, 0, `exit status of "${command}"`, result);
+  const envelope = parseEnvelope(result.stdout, 'stdout', result);
+  assertEqual(envelope.contract_version, CONTRACT_VERSION, 'contract_version', result);
+  assertEqual(envelope.ok, true, 'ok', result);
+  assertEqual(envelope.command, command, 'command', result);
+  return envelope;
+}
+
+/** Assert a failure envelope on stderr with a non-zero exit, and return it. */
+export function assertFailure(result, command, code) {
+  if (result.status === 0) {
+    throw new Error(`expected "${command}" to exit non-zero\n${describe(result)}`);
+  }
+  const envelope = parseEnvelope(result.stderr, 'stderr', result);
+  assertEqual(envelope.contract_version, CONTRACT_VERSION, 'contract_version', result);
+  assertEqual(envelope.ok, false, 'ok', result);
+  assertEqual(envelope.command, command, 'command', result);
+  if (code !== undefined)
+    assertEqual(envelope.error?.code, code, `error code of "${command}"`, result);
+  return envelope;
+}
+
+/** The command list `doctor` publishes — the discovery answer clients build on. */
+export function publishedCommands(host) {
+  return assertSuccess(academy(host, ['doctor', '--json']), 'doctor').commands;
+}
+
+/** Scaffold an agent through the binary under test, and fail loudly if it cannot. */
+export function hireAgent(host, name) {
+  return assertSuccess(academy(host, ['create', name, '--json']), 'create');
+}

package/conformance/identity.test.mjs

@@ -0,0 +1,125 @@
+// Identity containment — an agent Academy addresses is an agent inside its own
+// agents root, and nothing a caller supplies can move that boundary.
+//
+// The table below is the *agent-addressed* published commands: the ones that
+// name an agent. `doctor`, `list`, `sessions`, `events` and `migrate` are
+// published too, but they name no agent, so this vector cannot reach them and a
+// row for them could never pass.
+
+import assert from 'node:assert/strict';
+import { cpSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+import { academy, assertFailure, assertSuccess, createHost, hireAgent } from './harness.mjs';
+
+const UNSAFE = 'unsafe_agent_path';
+
+// Every published command that addresses an agent, with an invocation that
+// reaches its agent-resolution step.
+const AGENT_ADDRESSED = [
+  { command: 'inspect', args: () => ['inspect', 'kai'] },
+  { command: 'tokens', args: () => ['tokens', 'kai'] },
+  { command: 'budget', args: () => ['budget', 'kai'] },
+  { command: 'create', args: () => ['create', 'kai'] },
+  { command: 'hire', args: (host) => ['hire', '--spec', join(host.root, 'kai.json')] },
+  { command: 'rename', args: () => ['rename', 'kai', 'nova'] },
+  { command: 'archive', args: () => ['archive', 'kai'] },
+  { command: 'unarchive', args: () => ['unarchive', 'kai'] },
+  { command: 'delete', args: () => ['delete', 'kai'] },
+];
+
+// The commands that address an agent by the slot it occupies, so a slot
+// resolving outside the root reaches every one of them. They are asked a second
+// time against that vector, in two groups, because the two owe different
+// evidence: a move must not carry the root off, and a read must not publish
+// what it found outside. `create` and `hire` answer `agent_exists` for an
+// occupied slot and `unarchive` answers `agent_not_found` for an empty holding
+// area, so neither reaches the containment question by this route.
+const RELOCATING = ['rename', 'archive', 'delete'];
+const READING = ['inspect', 'tokens', 'budget'];
+
+function writeSpec(host) {
+  const spec = { name: 'kai', role: 'conformance subject', objective: 'exist' };
+  writeFileSync(join(host.root, 'kai.json'), JSON.stringify(spec));
+}
+
+// A root that is a symlink to a directory beside it, plus an ACADEMY_AGENT_DIR
+// naming that same out-of-root directory. Both vectors at once, so a command
+// that honoured either one would land outside the root.
+function escapedRoot(host) {
+  const escaped = join(host.root, 'escaped-root');
+  symlinkSync(host.outside, escaped);
+  return { AGENTS_ROOT: escaped, ACADEMY_AGENT_DIR: host.outside };
+}
+
+test('every agent-addressed command refuses an out-of-root root and agent directory', () => {
+  const host = createHost();
+  writeSpec(host);
+  hireAgent(host, 'kai');
+  const escaped = escapedRoot(host);
+
+  for (const { command, args } of AGENT_ADDRESSED) {
+    const result = academy(host, [...args(host), '--json'], escaped);
+    assertFailure(result, command, UNSAFE);
+  }
+
+  // The invariant, not the absence of one bug: after every refusal above,
+  // nothing was written outside the root and the agent is still addressable
+  // inside it.
+  assert.deepEqual(readdirSync(host.outside), []);
+  assertSuccess(academy(host, ['inspect', 'kai', '--json']), 'inspect');
+});
+
+test('a refusal never leaves the agents root half-moved', () => {
+  const host = createHost();
+  writeSpec(host);
+  hireAgent(host, 'kai');
+  const escaped = escapedRoot(host);
+  const before = readdirSync(host.agentsRoot).sort();
+
+  for (const { args } of AGENT_ADDRESSED) academy(host, [...args(host), '--json'], escaped);
+
+  assert.deepEqual(readdirSync(host.agentsRoot).sort(), before);
+  assert.deepEqual(readdirSync(host.outside), []);
+});
+
+// An agent directory carried out of the root, with its slot left behind as a
+// symlink to it. Every command that resolves an agent by name lands on it.
+function escapedSlot(host) {
+  const carried = join(host.outside, 'kai');
+  cpSync(join(host.agentsRoot, 'kai'), carried, { recursive: true });
+  rmSync(join(host.agentsRoot, 'kai'), { recursive: true });
+  symlinkSync(carried, join(host.agentsRoot, 'kai'));
+  return carried;
+}
+
+test('a command that moves an agent refuses a slot resolving outside the root', () => {
+  const host = createHost();
+  hireAgent(host, 'kai');
+  escapedSlot(host);
+  writeFileSync(join(host.outside, 'witness'), 'untouched\n');
+
+  for (const command of RELOCATING) {
+    const args = command === 'rename' ? [command, 'kai', 'zed'] : [command, 'kai'];
+    assertFailure(academy(host, [...args, '--json']), command, UNSAFE);
+  }
+
+  assert.deepEqual(readdirSync(host.outside).sort(), ['kai', 'witness']);
+});
+
+// The same vector against the commands that only read. They write nothing, so
+// the invariant they owe is the other one: an answer about an agent is evidence
+// that the agent lives where Academy says it does. A success here would report
+// content from outside the root under a `dir` field claiming to be inside it,
+// which is why the refusal — not the payload — is what a client can trust.
+test('a command that reads an agent refuses a slot resolving outside the root', () => {
+  const host = createHost();
+  hireAgent(host, 'kai');
+  const carried = escapedSlot(host);
+  writeFileSync(join(carried, 'role.md'), 'read from outside the agents root\n');
+
+  for (const command of READING) {
+    const envelope = assertFailure(academy(host, [command, 'kai', '--json']), command, UNSAFE);
+    assert.equal(envelope.dir, undefined, `${command} must publish no dir it did not resolve`);
+  }
+});