@iceinvein/agent-skills 0.2.0 → 0.4.0

package/skills/migrate/scripts/adapters/markdown.ts

@@ -0,0 +1,175 @@
+import { mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { Adapter, HandoffInput } from '../handoff.ts'
+import { buildWorkItems } from '../handoff.ts'
+import { readTextFile, writeAtomically } from '../store.ts'
+import type { ApplyResult, Completion, Requirement, Throughput, WorkItem } from '../types.ts'
+
+const OUT_DIR = join('docs', 'migrate')
+const CAP_DIR = join(OUT_DIR, 'capabilities')
+const ROADMAP = join(OUT_DIR, 'roadmap.md')
+
+// The roadmap's checkbox line is both what this adapter writes and what it
+// reads back, so the grammar is stated once and used from both directions.
+//
+// The date sits in an HTML comment rather than in parentheses after the id.
+// Parenthesised, it was indistinguishable from requirement text that happens
+// to open with one: a requirement reading "(2026-08-12) Raise an invoice"
+// parsed as a dated completion and fed a fabricated date straight into the
+// measured velocity, against the roadmap header's own promise that an undated
+// tick contributes nothing to the rate. A comment cannot be produced by
+// ordinary requirement prose, and an owner adding a date by hand copies the
+// form from the line above it.
+const LINE = /^- \[([ xX])\] (\S+)(?:\s+<!-- done:(\d{4}-\d{2}-\d{2}) -->)?\s*(.*)$/
+
+export type RoadmapState = Map<string, { checked: boolean; date: string | null }>
+
+export function parseRoadmap(text: string): RoadmapState {
+  const state: RoadmapState = new Map()
+  for (const line of text.split('\n')) {
+    const m = LINE.exec(line.trim())
+    if (!m) continue
+    const [, box, fr, date] = m
+    if (!fr) continue
+    state.set(fr, { checked: box?.toLowerCase() === 'x', date: date ?? null })
+    // A duplicated id would otherwise let the last line silently win.
+  }
+  return state
+}
+
+function checkboxLine(req: Requirement, state: RoadmapState): string {
+  const prior = state.get(req.id)
+  const box = prior?.checked ? 'x' : ' '
+  const date = prior?.checked && prior.date ? ` <!-- done:${prior.date} -->` : ''
+  return `- [${box}] ${req.id}${date} ${req.requirement}`
+}
+
+function renderRoadmap(items: WorkItem[], reqs: Requirement[], state: RoadmapState): string {
+  const lines = [
+    '# Migration roadmap',
+    '',
+    'Generated by `migrate handoff --adapter markdown`, in dependency order:',
+    'a capability appears after every capability it cites.',
+    '',
+    'Tick a box when the requirement is delivered, and record the date the',
+    'same way the line above it does: `<!-- done:YYYY-MM-DD -->` straight',
+    'after the id. `migrate coverage` reads this file, and `migrate forecast`',
+    'needs the dates, so an undated tick counts as built but contributes',
+    'nothing to the measured rate.',
+    '',
+  ]
+  items.forEach((item, i) => {
+    const own = reqs.filter((r) => r.cap === item.key)
+    lines.push(`## ${i + 1}. ${item.title}`)
+    lines.push('')
+    lines.push(`Depends on: ${item.dependsOn.length > 0 ? item.dependsOn.join(', ') : 'nothing'}`)
+    lines.push(`Detail: ${join(CAP_DIR, `${item.key}.md`)}`)
+    lines.push('')
+    if (own.length === 0) lines.push('No requirements were extracted for this capability.')
+    else for (const r of own) lines.push(checkboxLine(r, state))
+    lines.push('')
+  })
+  return lines.join('\n')
+}
+
+function cell(text: string): string {
+  return text.replace(/\|/g, '\\|').replace(/\n/g, ' ')
+}
+
+function renderCapability(item: WorkItem, reqs: Requirement[]): string {
+  const own = reqs.filter((r) => r.cap === item.key)
+  const lines = [
+    `# ${item.title}`,
+    '',
+    `- Key: ${item.key}`,
+    `- Depends on: ${item.dependsOn.length > 0 ? item.dependsOn.join(', ') : 'nothing'}`,
+    `- Requirements: ${item.weight}`,
+    '',
+    '## Functional requirements',
+    '',
+    '| id | requirement | actors | objects | rules | confidence | origin |',
+    '| --- | --- | --- | --- | --- | --- | --- |',
+  ]
+  for (const r of own) {
+    lines.push(
+      `| ${r.id} | ${cell(r.requirement)} | ${cell(r.actors)} | ${cell(r.objects)} | ${cell(r.rules)} | ${r.confidence.kind} | ${r.origin} |`,
+    )
+  }
+  lines.push('')
+  return lines.join('\n')
+}
+
+async function readIfPresent(path: string): Promise<string | null> {
+  try {
+    return await readTextFile(path)
+  } catch {
+    return null
+  }
+}
+
+export const markdown: Adapter = {
+  name: 'markdown',
+
+  async plan(input: HandoffInput): Promise<WorkItem[]> {
+    return buildWorkItems(input.capabilities, input.requirements)
+  },
+
+  async apply(items: WorkItem[], input: HandoffInput): Promise<ApplyResult> {
+    const src = input.config.source.path
+    await mkdir(join(input.root, CAP_DIR), { recursive: true })
+
+    // The roadmap is read before it is written, and every ticked box and its
+    // date is carried forward. Without this, running handoff a second time to
+    // pick up newly extracted requirements would silently erase the owner's
+    // record of what has been delivered. Re-running to finish a partial apply
+    // is behaviour the degradation contract requires, so it must not be the
+    // operation that loses data.
+    const roadmapPath = join(input.root, ROADMAP)
+    const existingRoadmap = await readIfPresent(roadmapPath)
+    const state = existingRoadmap ? parseRoadmap(existingRoadmap) : new Map()
+
+    const created: string[] = []
+    const updated: string[] = []
+    const unchanged: string[] = []
+    const refs: Record<string, string> = {}
+
+    for (const item of items) {
+      const rel = join(CAP_DIR, `${item.key}.md`)
+      const path = join(input.root, rel)
+      const next = renderCapability(item, input.requirements)
+      const before = await readIfPresent(path)
+      if (before === null) created.push(item.key)
+      else if (before !== next) updated.push(item.key)
+      else unchanged.push(item.key)
+      if (before !== next) await writeAtomically(path, next, src)
+      refs[item.key] = rel
+    }
+
+    const nextRoadmap = renderRoadmap(items, input.requirements, state)
+    if (existingRoadmap !== nextRoadmap) {
+      await writeAtomically(roadmapPath, nextRoadmap, src)
+      // The roadmap is part of what this adapter emits, so a run that rewrote
+      // it has not left everything unchanged. Without this the result could
+      // report every item `unchanged` while the roadmap was in fact replaced.
+      if (created.length === 0) {
+        for (const key of unchanged.splice(0, unchanged.length)) updated.push(key)
+      }
+    }
+
+    return { created, updated, unchanged, refs }
+  },
+
+  async throughput(input: HandoffInput): Promise<Throughput> {
+    const text = await readIfPresent(join(input.root, ROADMAP))
+    const basis = 'markdown roadmap checkboxes, dated in file'
+    if (text === null) return { completions: [], basis }
+    const completions: Completion[] = []
+    for (const [fr, entry] of parseRoadmap(text)) {
+      if (entry.checked) completions.push({ fr, doneAt: entry.date })
+    }
+    // Sorted by requirement id so two reads of one file agree, and so a
+    // coverage figure does not depend on where a line sits in the document.
+    completions.sort((a, b) => a.fr.localeCompare(b.fr))
+    return { completions, basis }
+  },
+}

package/skills/migrate/scripts/adjudicate-cmd.ts

@@ -0,0 +1,243 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { loadConfig } from './config.ts'
+import { LockError, withStoreLock } from './lock.ts'
+import { storePaths } from './paths.ts'
+import { recordBatch } from './phases.ts'
+import { loadQueue, parseQueueItem } from './queue.ts'
+import { readTextFile, writeAtomically } from './store.ts'
+import type { QueueItem, Severity } from './types.ts'
+
+const SEVERITIES: Severity[] = ['critical', 'moderate', 'minor']
+
+// The three keys this command owns. Everything else in a queue item's
+// frontmatter belongs to whoever wrote the item and passes through untouched.
+const OWNED = ['status', 'ruling', 'adjudicated'] as const
+
+// The review sheet exists so an owner can adjudicate a whole queue in one
+// sitting, which is what phase 6 asks for. Pulling each item's first
+// recommendation line into the list is the part that makes one pass possible:
+// without it the owner opens every file to find out what they are deciding.
+// Only the first line, because a recommendation may run to paragraphs and this
+// is an index, not the document.
+export function renderReviewSheet(items: QueueItem[]): string {
+  const sorted = [...items].sort((a, b) => {
+    const bySeverity = SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity)
+    return bySeverity !== 0 ? bySeverity : a.id.localeCompare(b.id)
+  })
+  const lines = sorted.map((item) => {
+    const head = `${item.id} [${item.severity}] ${item.status}`
+    const first = item.recommendation.split('\n')[0]?.trim() ?? ''
+    return first ? `${head} - ${first}` : head
+  })
+  const open = items.filter((i) => i.status === 'open').length
+  return [...lines, '', `${open} open`].join('\n')
+}
+
+// Rewrites only the three owned frontmatter keys, in place, and returns the
+// whole file. Two properties are load-bearing and both are asserted by test:
+//
+// Keys this command does not own keep their original position, rather than the
+// block being regenerated from a parsed map. A queue item's frontmatter is
+// hand-authored and may carry whatever the run found useful; reordering it
+// would show up as noise in every diff of an adjudicated item.
+//
+// The body is returned byte for byte. It is the audit record of why a ruling
+// was made, and a rewrite that reflows it destroys the thing being audited.
+// That is also why this works on lines rather than round-tripping through
+// parseQueueItem: the parser is lossy by design.
+export function applyRuling(text: string, ruling: string, date: string): string {
+  if (ruling.trim().length === 0) {
+    throw new Error('a ruling cannot be empty')
+  }
+  if (/[\n\r]/.test(ruling)) {
+    // A line break would let the value inject further frontmatter keys, or a
+    // closing fence, into the block it is written into. A value containing
+    // ':' or '---' is harmless by comparison: neither can reach line start.
+    throw new Error('a ruling cannot contain a newline')
+  }
+
+  // Normalised exactly as queue.ts normalises on read, and the fence located
+  // by the same rule it uses (a line STARTING with ---, not a line equal to it
+  // after trimming). The two disagreeing was not cosmetic: an indented `  ---`
+  // inside the frontmatter was invisible to the parser and taken as the fence
+  // here, so the owned keys were written above the real fence and the parser's
+  // last-key-wins read still saw `status: open`. `migrate adjudicate` printed
+  // "open -> adjudicated" and recorded a batch while the item stayed open
+  // forever, unreachable even with --force because its status never changed.
+  const normalized = text.startsWith('\uFEFF') ? text.slice(1) : text
+  const unix = normalized.replace(/\r\n/g, '\n')
+  const lines = unix.split('\n')
+  if (lines[0] !== '---') {
+    throw new Error('missing --- frontmatter block')
+  }
+  const close = lines.findIndex((line, i) => i > 0 && line.startsWith('---'))
+  if (close === -1) {
+    throw new Error('unterminated --- frontmatter block')
+  }
+
+  const updates = new Map<string, string>([
+    ['status', 'adjudicated'],
+    ['ruling', ruling],
+    ['adjudicated', date],
+  ])
+  const owned = new Set<string>(OWNED)
+  const seen = new Set<string>()
+  const rewritten: string[] = []
+  for (const line of lines.slice(1, close)) {
+    const sep = line.indexOf(':')
+    // An indented key belongs to a nested map, not to this document's top
+    // level. Trimming before comparing rewrote `  status: draft` under a
+    // `meta:` key into a de-indented top-level `status: adjudicated`, leaving
+    // two `status:` lines and a destroyed `meta` block.
+    if (sep === -1 || line !== line.trimStart()) {
+      rewritten.push(line)
+      continue
+    }
+    const key = line.slice(0, sep).trim()
+    seen.add(key)
+    if (owned.has(key)) rewritten.push(`${key}: ${updates.get(key)}`)
+    else rewritten.push(line)
+  }
+  for (const key of OWNED) {
+    if (!seen.has(key)) rewritten.push(`${key}: ${updates.get(key)}`)
+  }
+
+  return ['---', ...rewritten, ...lines.slice(close)].join('\n')
+}
+
+function today(): string {
+  return new Date().toISOString().slice(0, 10)
+}
+
+export async function runAdjudicate(opts: {
+  root: string
+  id?: string
+  ruling?: string
+  force?: boolean
+  forceUnlock?: boolean
+  now?: () => string
+}): Promise<number> {
+  const cfg = await loadConfig(opts.root)
+  const paths = storePaths(opts.root)
+  const { items, errors } = await loadQueue(paths.queueDir)
+
+  if (!opts.id) {
+    for (const e of errors) process.stderr.write(`adjudicate: ${e}\n`)
+    process.stdout.write(`${renderReviewSheet(items)}\n`)
+    return errors.length > 0 ? 1 : 0
+  }
+
+  if (opts.ruling === undefined) {
+    process.stderr.write('adjudicate: want --ruling <text> when an id is given\n')
+    return 2
+  }
+
+  const item = items.find((i) => i.id === opts.id)
+  if (!item) {
+    // Two different failures reach here and they are not the same class. A
+    // file that exists but will not parse is a real item whose content is
+    // broken: a content failure, and the parse errors are what the caller
+    // needs. An id with no file at all was never an item, so the request
+    // could not be serviced as posed: a usage error, the same code `queue
+    // add` returns for a file it cannot read.
+    const path = join(paths.queueDir, `${opts.id}.md`)
+    if (existsSync(path)) {
+      for (const e of errors) {
+        if (e.includes(path)) process.stderr.write(`adjudicate: ${e}\n`)
+      }
+      return 1
+    }
+    process.stderr.write(`adjudicate: no queue item ${opts.id}\n`)
+    return 2
+  }
+
+  if (item.status === 'adjudicated' && !opts.force) {
+    // The existing ruling is printed rather than merely referred to, so the
+    // caller can see what a --force would have replaced. An owner's recorded
+    // decision is not something a re-run should quietly overwrite, which is
+    // the one place this deliberately diverges from respec's applyRuling.
+    process.stderr.write(
+      `adjudicate: ${item.id} is already adjudicated: ${item.ruling ?? '<no ruling recorded>'}\n` +
+        'adjudicate: pass --force to replace it\n',
+    )
+    return 1
+  }
+
+  let text: string
+  try {
+    text = await readTextFile(item.path)
+  } catch (e) {
+    // The item was in the index a moment ago; its file vanishing between load
+    // and write is a domain failure on an otherwise well-formed request.
+    process.stderr.write(`adjudicate: ${(e as Error).message}\n`)
+    return 1
+  }
+
+  let next: string
+  try {
+    next = applyRuling(text, opts.ruling, (opts.now ?? today)())
+    // Checked against the parser every other command reads this file with,
+    // rather than trusted. A write that reports success while leaving the item
+    // open or unparseable is worse than a refusal, because the queue gate then
+    // blocks handoff over a decision the owner believes they recorded.
+    const reparsed = parseQueueItem(next, item.path)
+    if (!reparsed.ok) {
+      throw new Error(
+        `the rewritten file would not parse (${reparsed.errors.join('; ')}); the item's frontmatter is shaped in a way this command cannot safely edit`,
+      )
+    }
+    if (reparsed.value.status !== 'adjudicated' || reparsed.value.ruling !== opts.ruling) {
+      throw new Error(
+        "the rewritten file does not read back as adjudicated; the item's frontmatter is shaped in a way this command cannot safely edit",
+      )
+    }
+  } catch (e) {
+    // Every applyRuling throw is about the ruling text or the file's own
+    // frontmatter fence, both of which mean the request was malformed.
+    process.stderr.write(`adjudicate: ${(e as Error).message}\n`)
+    return 2
+  }
+
+  const before = item.status
+  try {
+    await withStoreLock(
+      opts.root,
+      async () => {
+        await writeAtomically(item.path, next, cfg.source.path)
+        // The batch is what lets the run-state gate see that phase 6 ran at
+        // all, the same role census records play for enumerate and extract.
+        // Keyed by item id so re-ruling one does not add a second entry.
+        await recordBatch(
+          opts.root,
+          'adjudicate',
+          { id: `b-adjudicate-${item.id}`, count: 1 },
+          cfg.source.path,
+        )
+      },
+      { cmd: 'adjudicate', ...(opts.forceUnlock ? { force: true } : {}) },
+    )
+  } catch (e) {
+    // Same class as every other writer: the request is fine and would succeed
+    // on retry, so it gets exit 3 rather than falling through to the generic
+    // guard at 2, which an orchestrator reads as "do not retry".
+    if (e instanceof LockError) {
+      process.stderr.write(`adjudicate: ${e.message}\n`)
+      return 3
+    }
+    throw e
+  }
+
+  process.stdout.write(
+    `adjudicate: ${item.id}\n` +
+      `  status  ${before} -> adjudicated\n` +
+      `  ruling  recorded\n` +
+      // This command deliberately writes no row file, so the consequence of
+      // the ruling (an element's disposition, a requirement's confidence) is
+      // still outstanding and goes through the writer that already validates
+      // it. Printing the command is how the phase manual's instruction
+      // reaches the operator at the moment it applies.
+      'next: apply the consequence with `migrate import`\n',
+  )
+  return 0
+}

package/skills/migrate/scripts/assumptions.ts

@@ -0,0 +1,188 @@
+import type { CapCoverage } from './coverage.ts'
+
+// The owner-attested half of forecasting. Everything measured lives in the
+// store and in the adapter's throughput; everything here is a judgment, and
+// the file carries who made it and when.
+//
+// The shape follows the flow target's forecast-assumptions.md (quartex/Nexus
+// at c2464ac, plugins/stack/templates/docs/modernisation/), because the
+// territory-and-multiplier model is both less to attest and more honest than
+// the per-requirement weighting table the parent spec first described: a
+// campaign names a handful of territories rather than a number per
+// requirement.
+//
+// One section of flow's file is deliberately absent. Its Economics table
+// carries dollar rates and token budgets derived from slice telemetry, which
+// this tool does not have and must not pretend to.
+
+export type Scenario = {
+  label: string
+  // `as-is` and `active` extrapolate a measured velocity. A positive number is
+  // an owner's target that no measurement backs, and the projection labels it
+  // so, which is the whole point of admitting all three.
+  rate: 'as-is' | 'active' | number
+  streams: number
+  tax: number
+  note: string
+}
+
+export type Assumptions = {
+  attestedBy: string
+  attestedDate: string
+  territories: Record<string, string>
+  multipliers: Record<string, number>
+  scenarios: Scenario[]
+  caveats: string[]
+}
+
+function parseFrontmatter(raw: string): { data: Record<string, string>; body: string } {
+  const lines = raw.split('\n')
+  if (lines[0]?.trim() !== '---') return { data: {}, body: raw }
+  const close = lines.findIndex((l, i) => i > 0 && l.trim() === '---')
+  if (close === -1) return { data: {}, body: raw }
+  const data: Record<string, string> = {}
+  for (const line of lines.slice(1, close)) {
+    const at = line.indexOf(':')
+    if (at === -1) continue
+    data[line.slice(0, at).trim()] = line.slice(at + 1).trim()
+  }
+  return { data, body: lines.slice(close + 1).join('\n') }
+}
+
+function extractSections(body: string): Record<string, string> {
+  const sections: Record<string, string> = {}
+  const parts = body.split(/\n## /).map((p, i) => (i === 0 ? p : `## ${p}`))
+  for (const part of parts) {
+    const m = part.match(/^## (.+)\n/)
+    if (!m?.[1]) continue
+    sections[m[1].trim()] = part.slice(m[0].length).trim()
+  }
+  return sections
+}
+
+// Markdown table rows minus the header and separator, cells trimmed. The file
+// is documentation and input at once, which is why it is a table rather than
+// TOML: the owner reads it as often as the tool does.
+// A markdown separator row is recognised rather than assumed to be the second
+// line. Dropping two lines positionally meant a table written without a
+// separator silently lost its first data row, which by the template's own
+// convention is the as-is measured baseline: the owner attested two scenarios
+// and got one, with no error anywhere.
+function isSeparator(cells: string[]): boolean {
+  return cells.length > 0 && cells.every((c) => /^:?-{1,}:?$/.test(c))
+}
+
+function tableRows(block: string): string[][] {
+  const rows = block
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l.startsWith('|'))
+    .map((l) =>
+      l
+        .split('|')
+        .slice(1, -1)
+        .map((c) => c.trim()),
+    )
+  // The first row is always the header. Anything after it that is a separator
+  // is structure, not data, wherever it sits.
+  return rows.slice(1).filter((cells) => !isSeparator(cells))
+}
+
+export function parseAssumptions(raw: string, path: string): Assumptions {
+  const { data, body } = parseFrontmatter(raw)
+  for (const field of ['attestedBy', 'attestedDate']) {
+    if (!data[field]) {
+      throw new Error(`forecast assumptions: missing ${field} in ${path}`)
+    }
+  }
+  const sections = extractSections(body)
+  for (const name of ['Territories', 'Multipliers', 'Scenarios']) {
+    if (sections[name] === undefined) {
+      throw new Error(`forecast assumptions: missing section "${name}" in ${path}`)
+    }
+  }
+
+  const territories: Record<string, string> = {}
+  for (const row of tableRows(sections.Territories ?? '')) {
+    if (row.length !== 2 || !row[0] || !row[1]) {
+      throw new Error(`forecast assumptions: bad territory row in ${path}: [${row.join(' | ')}]`)
+    }
+    territories[row[0]] = row[1]
+  }
+
+  const multipliers: Record<string, number> = {}
+  for (const row of tableRows(sections.Multipliers ?? '')) {
+    const value = Number(row[1])
+    if (row.length !== 2 || !row[0] || !Number.isFinite(value) || value <= 0) {
+      throw new Error(`forecast assumptions: bad multiplier row in ${path}: [${row.join(' | ')}]`)
+    }
+    multipliers[row[0]] = value
+  }
+
+  const scenarios: Scenario[] = tableRows(sections.Scenarios ?? '').map((row) => {
+    const [label, rateRaw, streamsRaw, taxRaw, note] = row
+    if (row.length !== 5 || !label) {
+      throw new Error(`forecast assumptions: bad scenario row in ${path}: [${row.join(' | ')}]`)
+    }
+    let rate: Scenario['rate']
+    if (rateRaw === 'as-is' || rateRaw === 'active') {
+      rate = rateRaw
+    } else {
+      const n = Number(rateRaw)
+      if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(
+          `forecast assumptions: scenario "${label}" rate must be as-is, active, or a positive requirements-per-day number in ${path}`,
+        )
+      }
+      rate = n
+    }
+    const streams = Number(streamsRaw)
+    if (!Number.isFinite(streams) || streams <= 0) {
+      throw new Error(
+        `forecast assumptions: scenario "${label}" streams must be a positive number in ${path}`,
+      )
+    }
+    const tax = Number(taxRaw)
+    if (!Number.isFinite(tax) || tax < 0 || tax >= 1) {
+      throw new Error(`forecast assumptions: scenario "${label}" tax must be in [0, 1) in ${path}`)
+    }
+    return { label, rate, streams, tax, note: note ?? '' }
+  })
+
+  const caveats = (sections.Caveats ?? '')
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l.startsWith('- '))
+    .map((l) => l.slice(2))
+
+  return {
+    attestedBy: data.attestedBy ?? '',
+    attestedDate: data.attestedDate ?? '',
+    territories,
+    multipliers,
+    scenarios,
+    caveats,
+  }
+}
+
+// Validated against measured coverage, not against itself. A capability with
+// nothing confirmed needs no territory, because it contributes nothing to
+// demand; one with confirmed requirements and no territory would silently
+// weigh whatever the fallback happened to be.
+export function validateAssumptions(a: Assumptions, coverage: CapCoverage[]): string[] {
+  const errors: string[] = []
+  for (const c of coverage) {
+    if (c.confirmedTotal > 0 && !a.territories[c.slug]) {
+      errors.push(
+        `capability ${c.slug} has ${c.confirmedTotal} confirmed requirement(s) but no territory in the forecast assumptions`,
+      )
+    }
+  }
+  for (const [slug, territory] of Object.entries(a.territories)) {
+    if (!(territory in a.multipliers)) {
+      errors.push(`territory "${territory}" (${slug}) has no multiplier`)
+    }
+  }
+  if (a.scenarios.length === 0) errors.push('no scenarios defined')
+  return errors
+}