@erclx/aitk 0.9.0 → 0.11.0

package/src/comments/trend.ts

@@ -0,0 +1,207 @@
+import { $ } from 'bun'
+import { gitEnv } from '@/git-env'
+import {
+  countFiles,
+  isPruned,
+  type Language,
+  LANGUAGES,
+  type LanguageCount,
+  languageFor,
+  type ScanOptions,
+  type SourceFile,
+} from '@/comments/scan'
+
+export interface TrendPoint {
+  readonly rev: string
+  readonly date: string
+  readonly languages: readonly LanguageCount[]
+}
+
+export const DEFAULT_POINTS = 6
+
+interface Commit {
+  readonly rev: string
+  readonly date: string
+}
+
+function parseCommits(text: string): Commit[] {
+  return text
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [rev, date] = line.split('\t')
+      return { rev, date }
+    })
+}
+
+/**
+ * Lists the commits from `since` to HEAD, oldest first and inclusive of
+ * `since` itself.
+ *
+ * A `since..HEAD` range excludes its own boundary, which drops the reading the
+ * caller is measuring against. The whole point of a trend is the before, so
+ * the boundary commit is prepended rather than left to the range operator.
+ *
+ * `--first-parent` keeps a merged branch's own commits out of the sample, so
+ * evenly spaced points land on the trunk rather than clustering inside
+ * whichever feature happened to carry the most commits.
+ */
+export async function listCommits(
+  root: string,
+  since: string,
+): Promise<Commit[]> {
+  const boundary =
+    await $`git -C ${root} log -1 --format=%H%x09%ad --date=short ${since}`
+      .env(gitEnv())
+      .quiet()
+      .nothrow()
+
+  if (boundary.exitCode !== 0) return []
+
+  const range =
+    await $`git -C ${root} log --first-parent --reverse --format=%H%x09%ad --date=short ${`${since}..HEAD`}`
+      .env(gitEnv())
+      .quiet()
+      .nothrow()
+
+  const commits = parseCommits(boundary.text())
+  if (range.exitCode === 0) commits.push(...parseCommits(range.text()))
+
+  return commits
+}
+
+/**
+ * Picks evenly spaced commits from `commits`, always keeping the newest.
+ *
+ * Sample selection matters more than sample size here. The reading the
+ * comment-discipline track needed came from four points spanning six months,
+ * so spacing across the window is what the arm optimizes for rather than
+ * density of coverage.
+ */
+export function spaceEvenly(
+  commits: readonly Commit[],
+  points: number,
+): Commit[] {
+  if (commits.length <= points) return [...commits]
+  if (points <= 1) return [commits[commits.length - 1]]
+
+  const picked: Commit[] = []
+  const step = (commits.length - 1) / (points - 1)
+
+  for (let index = 0; index < points; index++) {
+    picked.push(commits[Math.round(index * step)])
+  }
+
+  return picked
+}
+
+/**
+ * Reads every scannable blob at `rev` without checking anything out.
+ *
+ * `ls-tree` names the blobs and `cat-file --batch` streams their contents in
+ * one process, so a six-point trend costs six subprocesses rather than one per
+ * file per commit. Contents arrive as bytes, so the batch stream is walked by
+ * byte offset rather than split as text.
+ */
+export async function readRevision(
+  root: string,
+  rev: string,
+  languages: readonly Language[] = LANGUAGES,
+): Promise<SourceFile[]> {
+  const listed = await $`git -C ${root} ls-tree -r -z ${rev}`
+    .env(gitEnv())
+    .quiet()
+    .nothrow()
+  if (listed.exitCode !== 0) return []
+
+  const wanted: { oid: string; path: string }[] = []
+
+  for (const entry of listed.text().split('\0')) {
+    if (!entry) continue
+    const [meta, path] = entry.split('\t')
+    if (!path) continue
+
+    const [, type, oid] = meta.split(/\s+/)
+    if (type !== 'blob') continue
+    if (isPruned(path)) continue
+
+    const language = languageFor(path)
+    if (!language || !languages.includes(language)) continue
+
+    wanted.push({ oid, path })
+  }
+
+  if (wanted.length === 0) return []
+
+  const stdin = Buffer.from(`${wanted.map(({ oid }) => oid).join('\n')}\n`)
+  const batch = await $`git -C ${root} cat-file --batch < ${stdin}`
+    .env(gitEnv())
+    .quiet()
+    .nothrow()
+
+  if (batch.exitCode !== 0) return []
+
+  return parseBatch(Buffer.from(batch.arrayBuffer()), wanted)
+}
+
+/**
+ * Walks `git cat-file --batch` output, which frames each object as
+ * `<oid> SP <type> SP <size> LF <contents> LF`. The size header is the only
+ * safe way to find the next record, since contents may hold anything.
+ */
+function parseBatch(
+  buffer: Buffer,
+  wanted: readonly { oid: string; path: string }[],
+): SourceFile[] {
+  const files: SourceFile[] = []
+  let offset = 0
+
+  for (const { path } of wanted) {
+    const headerEnd = buffer.indexOf(0x0a, offset)
+    if (headerEnd === -1) break
+
+    const header = buffer.toString('utf8', offset, headerEnd)
+    const size = Number(header.split(' ')[2])
+    if (!Number.isFinite(size)) break
+
+    const start = headerEnd + 1
+    files.push({ path, text: buffer.toString('utf8', start, start + size) })
+    offset = start + size + 1
+  }
+
+  return files
+}
+
+/** Counts one revision's tree, reusing the same pass the snapshot arm runs. */
+export async function scanRevision(
+  root: string,
+  rev: string,
+  opts: ScanOptions = {},
+): Promise<LanguageCount[]> {
+  const files = await readRevision(root, rev, opts.languages ?? LANGUAGES)
+  return countFiles(files, opts)
+}
+
+export interface TrendOptions extends ScanOptions {
+  readonly since: string
+  readonly points?: number
+}
+
+/** Recomputes the series from git rather than reading a stored ledger. */
+export async function trend(
+  root: string,
+  opts: TrendOptions,
+): Promise<TrendPoint[]> {
+  const commits = await listCommits(root, opts.since)
+  const sampled = spaceEvenly(commits, opts.points ?? DEFAULT_POINTS)
+
+  // Each point is an independent pair of git reads, and the sample is bounded
+  // by `points`, so the whole series costs one revision's wall clock.
+  return Promise.all(
+    sampled.map(async ({ rev, date }) => ({
+      rev,
+      date,
+      languages: await scanRevision(root, rev, opts),
+    })),
+  )
+}

package/src/comments/vocabulary.ts

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+/**
+ * The heading a rule carries to publish its degradation list.
+ *
+ * Discovery is anchored on this rather than on a filename, because governance
+ * rules are numbered and a renumber would silently empty the vocabulary while
+ * the sweep kept reporting clean. A heading survives the rename.
+ */
+export const VOCABULARY_HEADING = '## Degradation vocabulary'
+
+/**
+ * Roots searched in order. The installed copy wins over the toolkit source, so
+ * a target project measures against the rule it actually has rather than one
+ * only the toolkit carries.
+ */
+const RULE_ROOTS = ['.claude/rules', 'governance/rules']
+
+/**
+ * Absent is a distinct state from empty.
+ *
+ * A sweep with no vocabulary finds nothing, and reporting that as zero hits
+ * claims the codebase is clean when nothing was actually looked for. The
+ * command reports it as skipped instead.
+ */
+export type Vocabulary =
+  | {
+      readonly kind: 'loaded'
+      readonly source: string
+      readonly terms: string[]
+    }
+  | { readonly kind: 'absent' }
+
+/** Pulls the backticked terms out of the bullets under the vocabulary heading. */
+export function parseVocabulary(markdown: string): string[] | undefined {
+  const lines = markdown.split('\n')
+  const start = lines.findIndex((line) => line.trim() === VOCABULARY_HEADING)
+  if (start === -1) return undefined
+
+  const terms: string[] = []
+
+  for (const line of lines.slice(start + 1)) {
+    if (line.startsWith('## ')) break
+    for (const match of line.matchAll(/`([^`]+)`/g)) {
+      const term = match[1].trim()
+      if (term && !terms.includes(term)) terms.push(term)
+    }
+  }
+
+  return terms
+}
+
+/**
+ * Finds the rule publishing the vocabulary under `root`.
+ *
+ * Reading the list out of the rule rather than hardcoding it is what keeps one
+ * definition when the rule installs into a target, the same way
+ * `.claude/hooks/standards-audit.sh` reads its bans out of `prose.md`.
+ */
+export async function loadVocabulary(root: string): Promise<Vocabulary> {
+  for (const ruleRoot of RULE_ROOTS) {
+    const dir = resolve(root, ruleRoot)
+    if (!existsSync(dir)) continue
+
+    const paths: string[] = []
+    for await (const rel of new Bun.Glob('**/*.md').scan({
+      cwd: dir,
+      onlyFiles: true,
+    })) {
+      paths.push(rel)
+    }
+    paths.sort()
+
+    for (const rel of paths) {
+      const parsed = parseVocabulary(await readFile(resolve(dir, rel), 'utf8'))
+      if (parsed && parsed.length > 0) {
+        return { kind: 'loaded', source: `${ruleRoot}/${rel}`, terms: parsed }
+      }
+    }
+  }
+
+  return { kind: 'absent' }
+}

package/src/git-env.ts

@@ -0,0 +1,36 @@
+/**
+ * Repository-resolution variables git reads from the environment.
+ *
+ * A git hook exports these into every process it runs, and they take
+ * precedence over `-C`. A command scoped to a subtree then silently reads
+ * whatever the hook's repository points at and reports figures for a tree
+ * nobody asked about, which is worse than failing because the output looks
+ * ordinary. `GIT_PREFIX` is here for the same reason: it re-anchors a relative
+ * pathspec to the directory the hook was invoked from.
+ */
+const RESOLUTION_VARS = [
+  'GIT_DIR',
+  'GIT_WORK_TREE',
+  'GIT_COMMON_DIR',
+  'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY',
+  'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+  'GIT_NAMESPACE',
+  'GIT_PREFIX',
+]
+
+/**
+ * Returns the ambient environment with git's repository-resolution variables
+ * removed, so `git -C <path>` resolves against `<path>` and nothing else.
+ *
+ * Read per call rather than captured at module load. A long-lived process can
+ * have these set after import, and a snapshot would then hand git the very
+ * variables this exists to strip.
+ */
+export function gitEnv(): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([key, value]) => value !== undefined && !RESOLUTION_VARS.includes(key),
+    ),
+  ) as Record<string, string>
+}

package/src/git-ignore.ts

@@ -0,0 +1,46 @@
+import { resolve } from 'node:path'
+import { $ } from 'bun'
+import { gitEnv } from '@/git-env'
+
+/**
+ * Reports which of `candidates` git ignores under `root`.
+ *
+ * Batched through one `check-ignore --stdin` rather than a call per path,
+ * since a whole-repo walk hands this thousands of candidates. Outside a git
+ * repo nothing is ignored, so a caller's segment prune becomes the only filter
+ * that applies.
+ */
+export async function listIgnored(
+  root: string,
+  candidates: string[],
+): Promise<Set<string>> {
+  if (candidates.length === 0) return new Set()
+
+  const isRepo = await $`git -C ${root} rev-parse --git-dir`
+    .env(gitEnv())
+    .quiet()
+    .nothrow()
+    .then((result) => result.exitCode === 0)
+
+  if (!isRepo) return new Set()
+
+  const stdin = Buffer.from(`${candidates.join('\n')}\n`)
+
+  const result = await $`git -C ${root} check-ignore --stdin < ${stdin}`
+    .env(gitEnv())
+    .quiet()
+    .nothrow()
+
+  // Exit 1 means nothing matched, which is a clean result rather than a
+  // failure. Anything above that is a real error and degrades to "ignores
+  // nothing" so a broken git never silently shrinks the scanned set.
+  if (result.exitCode > 1) return new Set()
+
+  return new Set(
+    result
+      .text()
+      .split('\n')
+      .filter(Boolean)
+      .map((path) => resolve(root, path)),
+  )
+}

package/src/gov/consumed.ts

@@ -0,0 +1,129 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { rm } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+import {
+  installRules,
+  installedRulesDir,
+  lookupRules,
+  type RuleSource,
+  ruleSubdir,
+} from '@/gov/install'
+import { mergeExtraRules, resolveRules } from '@/gov/stacks'
+
+export const RECORD_REL = join('internal', 'governance.toml')
+
+const INTERNAL_RULES_REL = join('internal', 'rules')
+
+/** The stack a repository installs into its own `.claude/rules/`. */
+export interface ConsumedRecord {
+  readonly stack: string
+  readonly add: readonly string[]
+}
+
+export type ConsumedResult =
+  | { readonly ok: true; readonly installed: readonly string[] }
+  | { readonly ok: false; readonly reason: string }
+
+export function consumedRecordPath(root: string): string {
+  return join(root, RECORD_REL)
+}
+
+export function internalRulesDir(root: string): string {
+  return join(root, INTERNAL_RULES_REL)
+}
+
+/**
+ * Reads the record naming the consumed stack. A file with no `stack` reads the
+ * same as no file at all, since neither tells the producer what to install and
+ * the caller's message covers both.
+ */
+export function readConsumedRecord(root: string): ConsumedRecord | undefined {
+  const path = consumedRecordPath(root)
+  if (!existsSync(path)) return undefined
+
+  const parsed = Bun.TOML.parse(readFileSync(path, 'utf8')) as Record<
+    string,
+    unknown
+  >
+  const stack = typeof parsed.stack === 'string' ? parsed.stack : ''
+  if (stack === '') return undefined
+
+  return {
+    stack,
+    add: Array.isArray(parsed.add)
+      ? parsed.add.filter(
+          (rule): rule is string => typeof rule === 'string' && rule !== '',
+        )
+      : [],
+  }
+}
+
+/**
+ * Lists rules authored under `internal/rules/`. These govern toolkit authoring
+ * against paths only this repository has, so they install into the consumed
+ * copy without ever entering `governance/rules/`, which ships to targets.
+ */
+export function listInternalRules(root: string): RuleSource[] {
+  const dir = internalRulesDir(root)
+  if (!existsSync(dir)) return []
+
+  return [...new Bun.Glob('**/*.md').scanSync({ cwd: dir, onlyFiles: true })]
+    .sort()
+    .map((rel) => {
+      const src = join(dir, rel)
+      return { rule: basename(rel, '.md'), src, subdir: ruleSubdir(src, dir) }
+    })
+}
+
+/**
+ * Rebuilds a repository's own `.claude/rules/` from its record. Unlike
+ * `gov install` and `gov sync`, this runs against the toolkit root on purpose:
+ * those two refuse it because a target's rules are the operator's to edit,
+ * while this destination is produced output that happens to live beside its
+ * source.
+ */
+export async function regenConsumedRules(
+  root: string,
+): Promise<ConsumedResult> {
+  const record = readConsumedRecord(root)
+  if (record === undefined) {
+    return { ok: false, reason: `No stack recorded at ${RECORD_REL}` }
+  }
+
+  const resolution = resolveRules(root, record.stack)
+  if (!resolution.ok) {
+    return { ok: false, reason: `Stack not found: ${resolution.missingStack}` }
+  }
+
+  const { found, missing } = lookupRules(
+    root,
+    mergeExtraRules(resolution.rules, record.add.join(',')),
+  )
+  if (missing.length > 0) {
+    return { ok: false, reason: `No source for: ${missing.join(', ')}` }
+  }
+
+  const internal = listInternalRules(root)
+  const stackRules = new Set(found.map((entry) => entry.rule))
+  const shadowed = internal
+    .filter((entry) => stackRules.has(entry.rule))
+    .map((entry) => entry.rule)
+  if (shadowed.length > 0) {
+    return {
+      ok: false,
+      reason: `Internal rules shadow stack rules: ${shadowed.join(', ')}`,
+    }
+  }
+
+  // Clearing first is what makes a rule the record stopped naming disappear.
+  // Copying over the destination would leave it behind as an unsourced file,
+  // which is the state this producer exists to end.
+  await rm(installedRulesDir(root), { recursive: true, force: true })
+
+  const installed = [
+    ...(await installRules(found, root)),
+    ...(await installRules(internal, root)),
+  ]
+
+  return { ok: true, installed: installed.sort() }
+}

package/src/indexes/walk.ts

@@ -1,6 +1,6 @@
 import { existsSync, statSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
-import { $ } from 'bun'
+import { listIgnored } from '@/git-ignore'
 
 const INDEX_FILE = 'index.md'
 
@@ -42,34 +42,6 @@ export async function listIndexes(root: string): Promise<string[]> {
   return candidates.filter((path) => !ignored.has(path))
 }
 
-async function listIgnored(
-  root: string,
-  candidates: string[],
-): Promise<Set<string>> {
-  const isRepo = await $`git -C ${root} rev-parse --git-dir`
-    .quiet()
-    .nothrow()
-    .then((result) => result.exitCode === 0)
-
-  if (!isRepo) return new Set()
-
-  const stdin = Buffer.from(`${candidates.join('\n')}\n`)
-
-  const result = await $`git -C ${root} check-ignore --stdin < ${stdin}`
-    .quiet()
-    .nothrow()
-
-  if (result.exitCode > 1) return new Set()
-
-  return new Set(
-    result
-      .text()
-      .split('\n')
-      .filter(Boolean)
-      .map((path) => resolve(root, path)),
-  )
-}
-
 /**
  * Reports whether git ignores `path`.
  *

package/standards/index.md

@@ -12,7 +12,7 @@ Reference docs for consistent authoring across the toolkit and target projects.
 - [Design reference](design.md): Shape and content rules for .claude/DESIGN.md
 - [Diagram reference](diagrams.md): Shape and content rules for .claude/diagrams/<kind>.md files
 - [Prose reference](prose.md): Voice, structure, formatting, and language rules for reference markdown
-- [Readme reference](readme.md): Readme structure and content conventions
+- [Readme reference](readme.md): Readme voice, structure, and content conventions
 - [Requirements reference](requirements.md): Shape and content rules for .claude/REQUIREMENTS.md
 - [Governance rule reference](rule.md): Rule frontmatter, body shape, and voice for .claude/rules files
 - [Claude skill reference](skill.md): Claude skill structure and authoring rules

package/standards/prose.md

@@ -5,7 +5,7 @@ description: Voice, structure, formatting, and language rules for reference mark
 
 # Prose reference
 
-Applies to markdown reference docs, READMEs, and inline documentation in repos. It is the default voice for `.md` files and yields to any surface with its own voice, such as blogs, emails, changelogs, or commit messages. It also yields wherever another standard states the voice for the surface it governs, which is how a surface claims the exemption without this file having to name it. The yield covers voice alone. Punctuation, formatting, and language rules below stay in force on every surface, since the standards-audit hook is the only gate on published text.
+Applies to markdown reference docs, READMEs, and inline documentation in repos. It is the default voice for `.md` files and yields to any surface with its own voice, such as blogs, emails, changelogs, or commit messages. It also yields wherever another standard states the voice for the surface it governs, which is how a surface claims the exemption without this file having to name it. The yield covers voice alone. Punctuation, formatting, and language rules below stay in force on every surface, including the surfaces no automated check reaches, which is what the scan below is for.
 
 ## Voice
 
@@ -74,6 +74,19 @@ Applies to markdown reference docs, READMEs, and inline documentation in repos.
 - Do not address the reader as a participant (`Let's`, `Here's`, `Here are`). State the content directly.
 - Commit to a position. Do not hedge in clusters (`It might be worth considering`) or use false balance (`While X is true, Y is also important`). Recommend, or state the tradeoff.
 
+## Banned-character scan
+
+Wherever text leaves through a channel no automated check covers, the author is the only gate and runs this scan. Text sent to another service, written to a path the project's checks exclude, and text inside a fenced block are the usual cases. The surface that publishes the text is what knows which gap applies, so it names its own rather than reading one here.
+
+Scan the drafted text and rewrite each occurrence:
+
+- `—` (em dash): split into two sentences, or use a comma
+- `;` (semicolon): split into two sentences
+
+Restructure the sentence rather than substituting the character. A semicolon swapped for a period leaves both clauses in the order the semicolon chose, which is the shape the ban exists to remove.
+
+Run the scan as an explicit step against the finished text. Having read this file before drafting does not cover it, because the check has to happen after the text exists.
+
 ## Frontmatter descriptions
 
 When frontmatter carries a short `title` or `description` used for catalog display:

package/standards/readme.md

@@ -1,10 +1,24 @@
 ---
 title: Readme reference
-description: Readme structure and content conventions
+description: Readme voice, structure, and content conventions
 ---
 
 # Readme reference
 
+Applies to every `README.md`. The `## Voice` section states the voice for a repository's root README, so `prose.md` yields to it there. The yield covers voice alone. The punctuation bans, spelling rules, banned words, and formatting rules in `prose.md` stay in force, so the warmer register ships with the same hygiene: no em dashes, no semicolons, no buzzwords.
+
+The reader is what changes. Reference prose serves someone who already committed to the project and is scanning for a fact. A root README meets someone deciding whether to commit at all, and it is often the only file they read.
+
+## Voice
+
+Scoped to the README at a repository root. A nested README documenting a folder, a harness, or an internal tool keeps the reference voice in `prose.md`, since its reader has already committed and arrived looking for a fact.
+
+- Address the reader in second person. First-person plural needs an authoring organization as its antecedent, so a single-maintainer project has none to use.
+- Use contractions wherever the sentence reads better for one. Do not force them in.
+- Write with a point of view. State what the project chose and why, not a neutral survey of the options it passed over.
+- Ground a claim in something concrete rather than an adjective. A command, a number, or a named constraint carries more than a description of quality.
+- Be honest about limits. Naming what the project does not do reads as more credible, not less.
+
 ## Structure
 
 - H1 title, H2 major sections, H3 subsections. Maintain proper hierarchy for GitHub's auto-generated table of contents.

package/standards/skill.md

@@ -173,6 +173,18 @@ Without this skill, a session <observed failure>, <observed failure>.
 - When a skill gathers user input or pre-seeds a template, attach a concrete proposed default to every question, derived from project context. Accept "use defaults" as a bulk-confirm.
 - Separate correctness axes (routing, sourcing, escalation, decline) from shape axes (line count, formatting, variant sprawl) when tuning a skill. Tighten only on correctness regressions. Do not convert soft caps to hard caps for aesthetic drift when correctness passes.
 
+### Deriving the branch slug
+
+Run `git branch --show-current` and replace every `/` with `-`. The result is `<slug>`. Anything reading a branch-derived name uses this transform, so two skills cannot spell it differently.
+
+A skill that persists output under `.claude/` carries the slug in the filename, which is what keeps parallel worktrees from overwriting each other's output.
+
+The empty result is a detached HEAD, and the skill picks one of three responses rather than inheriting a default. State the choice in the body, since the transform is shared and this is not.
+
+- Fall back to `latest`, so a read-only pass still writes somewhere predictable
+- Stop, when the skill commits or opens a pull request. There is no branch to put the work on, so `latest` would bury the problem instead of reporting it. State the stop in the skill's guards.
+- Fall through to the next source, when the slug is one candidate among several rather than the name of an output file
+
 ## Scripts
 
 - Use `scripts/` for operations that must be deterministic or repetitive
@@ -199,6 +211,8 @@ A standard reaches a skill by two routes, and a body that names only the first b
 - State the fallback once per body, at the site that reads the standard. A later mention of a standard the body already read stays bare, since repeating the fallback at every mention is noise rather than instruction.
 - A guard on a standard's presence names the file and tests both paths before it stops. A guard that tests only `.claude/standards/` refuses to run in a plugin-only project that has the file, and a guard that tests the directory passes in the partial-install case it exists to catch.
 - Use `${CLAUDE_SKILL_DIR}`, never a bare `../../` and never `${CLAUDE_PLUGIN_ROOT}`. Only `${CLAUDE_SKILL_DIR}` is expanded before the body reaches the model. The other two leave the model to infer a base path, which it may resolve against the session cwd instead.
+- Cite a shared procedure, never restate it. A procedure two or more skills execute gets one definition in a standard and a citation in each body. Nothing catches a restatement that drifts, because the drift assertion covers generated copies and a hand-written one is not generated, so the guarantee is only that a single definition exists to correct.
+- Keep the trigger in the body and the procedure in the standard. The citing skill states when the procedure runs and what it runs against, since that varies per skill and the standard cannot know it.
 
 ## Invocation