@erclx/canon 5.44.0 → 5.45.0

package/src/cli.ts

@@ -7,7 +7,6 @@ import { register as sync } from '@/commands/sync'
 import { register as gov } from '@/commands/gov'
 import { register as tooling } from '@/commands/tooling'
 import { register as claude } from '@/commands/claude'
-import { register as wiki } from '@/commands/wiki'
 import { register as indexes } from '@/commands/indexes'
 import { register as docs } from '@/commands/docs'
 import { register as design } from '@/commands/design'
@@ -68,7 +67,6 @@ sync(program)
 gov(program)
 tooling(program)
 claude(program)
-wiki(program)
 indexes(program)
 docs(program)
 design(program)

package/src/commands/gov.ts

@@ -37,6 +37,7 @@ import {
   hasFinding,
   PRACTICE_FOLDERS,
   readRuleAudit,
+  RULE_GATE_EXEMPT,
   RULE_GATED_FOLDERS,
   RULE_LIMITS,
   type RuleAuditReport,
@@ -631,6 +632,7 @@ export function register(program: Command): void {
         '  inside it.',
         '',
         `Gated folders: ${RULE_GATED_FOLDERS.length === 0 ? 'none yet' : RULE_GATED_FOLDERS.join(', ')}`,
+        `Exempt from the gate: ${RULE_GATE_EXEMPT.length === 0 ? 'none' : RULE_GATE_EXEMPT.join(', ')}`,
         '',
         'Exit codes:',
         '  0  no finding, or under --gate no finding in a gated folder',
@@ -691,6 +693,7 @@ async function runAudit(
         root,
         limits: RULE_LIMITS,
         gated: RULE_GATED_FOLDERS,
+        exempt: RULE_GATE_EXEMPT,
         ...report,
       })}\n`,
     )
@@ -699,6 +702,7 @@ async function runAudit(
   return auditExit(report, {
     gate: opts.gate ?? false,
     gated: RULE_GATED_FOLDERS,
+    exempt: RULE_GATE_EXEMPT,
   })
 }
 

package/src/commands/init.ts

@@ -39,8 +39,8 @@ export function register(program: Command): void {
         '',
         'Runs `canon tooling sync base --write` first, which replaces every',
         'base golden config the target holds, then `canon claude init`,',
-        '`canon gov install`, and `canon wiki init`. Refuses a target that is',
-        'not a directory or is the toolkit root.',
+        'and `canon gov install`. Refuses a target that is not a directory or is',
+        'the toolkit root.',
         '',
         'Exit codes:',
         '  0  every domain installed, or the prompt was cancelled',

package/src/commands/tooling.ts

@@ -1,4 +1,5 @@
-import { resolve } from 'node:path'
+import { existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
 import type { Command } from 'commander'
 import { checkoutMismatchWarning, PROJECT_ROOT } from '@/roots/project'
 import {
@@ -12,11 +13,16 @@ import { buildStackSummaries, describeStack } from '@/tooling/list'
 import {
   isStackExcluded,
   listStacks,
+  loadManifest,
   type Manifest,
   resolveChain,
   stackExists,
 } from '@/tooling/manifest'
-import { readReference, resolveReference } from '@/tooling/read'
+import {
+  readReference,
+  renderStackSections,
+  resolveReference,
+} from '@/tooling/read'
 import { scan, type ScanResult } from '@/tooling/scan'
 import { recordToolingChain } from '@/tooling/stamp'
 import { subfolderPath } from '@/tooling/subfolder'
@@ -302,6 +308,8 @@ function printReference(stack: string): number {
 
   logStep(resolved.source)
   process.stdout.write(readReference(resolved))
+  const manifest = loadManifest(resolved.root, stack)
+  if (manifest) process.stdout.write(renderStackSections(manifest))
   outro()
   return 0
 }
@@ -625,12 +633,16 @@ function report(result: ScanResult, target: string): void {
     if (entry.state === 'missing') logAdd(entry.rel)
   }
 
-  if (result.hasPackageJson) {
+  if (result.newManifest) {
+    logStep('Scanning package.json')
+    logAdd('package.json')
+    reportPackage(result)
+  } else if (result.hasPackageJson) {
     reportPackage(result)
-  } else {
+  } else if (existsSync(join(target, 'package.json'))) {
     logStep('Scanning package.json')
     logWarn(
-      "Skipped scripts and deps: no package.json found (run 'bun init' to enable)",
+      `Skipped scripts and deps: package.json is not valid JSON (fix it in ${target}, then sync again)`,
     )
   }
 
@@ -688,6 +700,7 @@ function summarize(result: ScanResult): string {
     if (count > 0) parts.push(`${count} ${label}`)
   }
 
+  add(result.newManifest ? 1 : 0, 'package.json')
   add(
     result.configs.filter((entry) => entry.state !== 'matching').length,
     'configs',

package/src/design/components.ts

@@ -520,7 +520,7 @@ html.sb-shut .pane { border-left: 0; }
 }
 
 /* A bar link is its own tap target rather than a line of text, so it carries
-   the 24 pixel minimum the a11y rule sets. */
+   the 24 pixel minimum the keyboard rule sets. */
 .mast a,
 .mast summary {
   min-height: 1.6rem;

package/src/gov/audit.ts

@@ -36,6 +36,21 @@ export const RULE_GATED_FOLDERS: readonly string[] = [
   join('governance', 'rules', 'framework') + sep,
   join('governance', 'rules', 'writing') + sep,
   join('internal', 'rules') + sep,
+  join('governance', 'rules', 'lang') + sep,
+  join('governance', 'rules', 'lib') + sep,
+  join('governance', 'rules', 'ui') + sep,
+  join('governance', 'rules', 'tooling') + sep,
+]
+
+/**
+ * Rule files in a gated folder whose findings `--gate` still passes, one path
+ * each and never a folder, so a new rule beside one is gated the day it lands.
+ *
+ * `ui/canvas.md` carries a shape finding and no ledger, and v149.2 removes the
+ * rule, so this entry goes with it.
+ */
+export const RULE_GATE_EXEMPT: readonly string[] = [
+  join('governance', 'rules', 'ui', 'canvas.md'),
 ]
 
 /** The folders whose rules claim outside practice, so each carries a ledger. */
@@ -429,13 +444,18 @@ export function hasFinding(reading: RuleReading): boolean {
  */
 export function auditExit(
   report: Extract<RuleAuditReport, { kind: 'measured' }>,
-  options: { readonly gate: boolean; readonly gated: readonly string[] },
+  options: {
+    readonly gate: boolean
+    readonly gated: readonly string[]
+    readonly exempt?: readonly string[]
+  },
 ): number {
   const failing = report.rules.filter(
     (reading) =>
       hasFinding(reading) &&
       (!options.gate ||
-        options.gated.some((prefix) => reading.file.startsWith(prefix))),
+        (options.gated.some((prefix) => reading.file.startsWith(prefix)) &&
+          !options.exempt?.includes(reading.file))),
   )
   return failing.length > 0 ? 2 : 0
 }

package/src/init/plan.ts

@@ -1,4 +1,4 @@
-export const SKIPPABLE_DOMAINS = ['wiki', 'governance', 'records'] as const
+export const SKIPPABLE_DOMAINS = ['governance', 'records'] as const
 
 export type SkippableDomain = (typeof SKIPPABLE_DOMAINS)[number]
 
@@ -97,13 +97,6 @@ export function planInit(flags: InitFlags): InitPlan {
     })
   }
 
-  if (!flags.skip.skipped.has('wiki')) {
-    preview.push({
-      level: 'info',
-      text: 'wiki (.claude/wiki/ with a stub index)',
-    })
-  }
-
   if (!flags.skip.skipped.has('records')) {
     preview.push({
       level: 'info',

package/src/init/steps.ts

@@ -55,14 +55,6 @@ export function buildSteps(
     })
   }
 
-  if (!flags.skip.skipped.has('wiki')) {
-    steps.push({
-      kind: 'run',
-      label: 'Wiki',
-      run: child(['wiki', 'init', resolved]),
-    })
-  }
-
   if (!flags.skip.skipped.has('records')) {
     // `skip` here means there is nothing to run non-interactively, not that
     // the caller opted out, unlike every other push of this kind above.

package/src/inventory/subjects.ts

@@ -27,7 +27,7 @@ export interface Subject {
 
 /**
  * Reports what each element changes about itself when it takes focus, which is
- * the reading `governance/rules/ui/a11y.md` states three rules against and
+ * the reading `governance/rules/ui/keyboard.md` states three rules against and
  * nothing measures.
  *
  * The difference between rest and focus is the treatment, rather than the

package/src/markdown/scope.ts

@@ -114,6 +114,7 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/docs-sync/references/readme.md',
   'claude/skills/document-health/SKILL.md',
   'claude/skills/document-health/references/axes.md',
+  'claude/skills/pick-by-eye/REQUIREMENT.md',
   'claude/skills/pick-by-eye/SKILL.md',
   'claude/skills/pick-by-eye/references/live-arms.md',
   'claude/skills/write-doc/SKILL.md',
@@ -204,6 +205,7 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/review-ui/references/hosted-preview.md',
   'claude/skills/review-ui/references/post.md',
   'claude/skills/review-ui/references/tick.md',
+  'claude/skills/role-orchestrator/REQUIREMENT.md',
   'claude/skills/role-orchestrator/SKILL.md',
   'claude/skills/role-orchestrator/references/orchestrator-cloud-launch.md',
   'claude/skills/role-orchestrator/references/orchestrator-dispatch.md',
@@ -221,8 +223,10 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/role-orchestrator/references/orchestrator-reviewer-launch.md',
   'claude/skills/role-orchestrator/references/orchestrator-sweep.md',
   'claude/skills/role-orchestrator/references/orchestrator-watch.md',
+  'claude/skills/role-planner/REQUIREMENT.md',
   'claude/skills/role-planner/SKILL.md',
   'claude/skills/role-reviewer/SKILL.md',
+  'claude/skills/role-worker/REQUIREMENT.md',
   'claude/skills/role-worker/SKILL.md',
   'claude/skills/search-craft/SKILL.md',
   'claude/skills/search-craft/references/adopted.md',

package/src/migrate/scratch-evidence.ts

@@ -34,7 +34,7 @@ import {
   slugOf,
 } from '@/migrate/evidence-ordinal'
 import { presentFolders } from '@/records/backup'
-import { recordDir, SCRATCH } from '@/roots/record'
+import { LEGACY_SCRATCH_REL, recordDir, SCRATCH } from '@/roots/record'
 
 /**
  * Every folder this promotion moves, at the name it carries under scratch.
@@ -64,9 +64,17 @@ export const PROMOTED_FOLDERS: readonly string[] = [
   'target-survey',
 ]
 
-/** Where a promoted folder sits before the move. */
+/**
+ * Where a promoted folder sits before the move: `.canon/tmp` when it holds the
+ * folder, so a target part-way through a move promotes the newer copy, and the
+ * retired scratch folder otherwise. The verb is a migration, so it reads an
+ * unmigrated target where it is.
+ */
 export function sourcePath(root: string, folder: string): string {
-  return recordDir(root, SCRATCH, folder)
+  const current = recordDir(root, SCRATCH, folder)
+  const legacy = join(root, LEGACY_SCRATCH_REL, folder)
+
+  return !existsSync(current) && existsSync(legacy) ? legacy : current
 }
 
 /** The folder a promoted one lands inside, under whichever root carries it. */
@@ -85,7 +93,7 @@ function escape(value: string): string {
  * swallowing a sibling folder whose name extends it.
  */
 const OLD_PREFIXES = [
-  '.claude/.tmp/',
+  '.claude/.tmp/', // canon-keep-record-root
   '.canon/tmp/',
   '../.tmp/',
   '../tmp/',

package/src/records/backup.ts

@@ -107,9 +107,9 @@ export const EXCLUDED_ENTRIES = [
 /**
  * Whether a top-level name stays out of every push, at either root.
  *
- * `SCRATCH` is the legacy `.tmp` spelling, which a records index opened before
- * the move can still carry and which `EXCLUDED_ENTRIES` names at its `.canon`
- * spelling only.
+ * `SCRATCH` is the retired `.tmp` spelling. It is a guard rather than a lookup,
+ * keeping a stray `.tmp` out of a push, and `EXCLUDED_ENTRIES` names the
+ * `.canon` spelling only.
  */
 function isExcluded(name: string): boolean {
   return (

package/src/records/validate.ts

@@ -228,9 +228,9 @@ const PLAN_REQUIRED: readonly PlanSection[] = [
 ]
 
 /**
- * The files whose edit changes what a person sees, the set the `ui/a11y` rule
- * globs plus the other markup and style extensions a plan names. A plan touching
- * one owes a `Design references` section, so a set too wide forces it on every
+ * The files whose edit changes what a person sees, the set the `ui/a11y` and
+ * `ui/keyboard` rules glob plus the other markup and style extensions a plan
+ * names. A plan touching one owes a `Design references` section, so a set too wide forces it on every
  * plan and one too narrow lets a UI plan skip it.
  */
 const RENDERED_SURFACE = /\.(?:tsx|jsx|astro|vue|svelte|html|css|scss)$/

package/src/roots/record.ts

@@ -29,17 +29,22 @@ export type RecordRoot = (typeof RECORD_ROOTS)[number]
 export const CREATION_ROOT: RecordRoot = '.canon'
 
 /**
- * The deletable scratch folder, named at the spelling `.claude/` gives it.
+ * The deletable scratch folder, named at the spelling `.claude/` gave it.
  *
- * It is the one folder whose name differs by root, and callers name it at the
- * old spelling because `spell` is the only place the variant is decided. Inside
- * a dotted root the leading dot hides nothing already hidden and costs a bare
- * `ls` that omits the folder, so the move dropped it. Every other record folder
- * keeps its name, `.records.git` included, where the dot marks the mechanism
- * apart from a payload rather than hiding it.
+ * Scratch resolves at `.canon/tmp` only. The `.claude/.tmp` spelling is a
+ * migration source, named through `LEGACY_SCRATCH_REL` by the verbs that move
+ * it, and no lookup falls back to it. Callers still name the folder at this
+ * spelling because `spell` is the only place the variant is decided. Inside a
+ * dotted root the leading dot hides nothing already hidden and costs a bare
+ * `ls` that omits the folder, so the move dropped it. Every other record
+ * folder keeps its name, `.records.git` included, where the dot marks the
+ * mechanism apart from a payload rather than hiding it.
  */
 export const SCRATCH = '.tmp'
 
+/** The retired scratch location, read only as the source of a migration. */
+export const LEGACY_SCRATCH_REL = '.claude/.tmp' // canon-keep-record-root
+
 /** The scratch folder's name under `.canon/`. */
 const CANON_SCRATCH = 'tmp'
 
@@ -109,6 +114,8 @@ export function spell(root: RecordRoot, folder: string): string {
  * records it belongs to rather than at the creation default.
  */
 function rootOf(root: string, folder: string): RecordRoot {
+  if (folder === SCRATCH) return CREATION_ROOT
+
   return (
     RECORD_ROOTS.find((candidate) =>
       existsSync(join(root, candidate, spell(candidate, folder))),
@@ -147,7 +154,9 @@ export function recordDirs(
   folder: string,
   ...rest: string[]
 ): string[] {
-  return RECORD_ROOTS.map((candidate) =>
+  const candidates = folder === SCRATCH ? [CREATION_ROOT] : RECORD_ROOTS
+
+  return candidates.map((candidate) =>
     join(root, candidate, spell(candidate, folder), ...rest),
   )
 }

package/src/tooling/inject.ts

@@ -16,6 +16,8 @@ import {
 import {
   applyScripts,
   collectDeps,
+  declaresInstalls,
+  minimalPackage,
   readPackage,
   serializePackage,
 } from '@/tooling/package'
@@ -156,15 +158,22 @@ export async function pruneGitignore(
 
 /**
  * Installs missing dev dependencies, fills package scripts, and merges
- * gitignore entries. A target with no package.json gets the gitignore alone,
- * plus a warning naming every install it skipped, since seeding a package.json
- * would pick a package manager and a project name on the target's behalf.
+ * gitignore entries. A target with no package.json gets a minimal one first
+ * when the chain installs anything. A package.json that exists but cannot be
+ * parsed is never rewritten, and the install is skipped with a warning.
  */
 export async function injectManifest(
   chain: readonly Manifest[],
   target: string,
 ): Promise<void> {
   const packagePath = join(target, 'package.json')
+
+  if (!existsSync(packagePath) && declaresInstalls(chain)) {
+    logStep('Writing package.json')
+    await writeFile(packagePath, serializePackage(minimalPackage(target)))
+    logAdd('package.json')
+  }
+
   const pkg = readPackage(packagePath)
 
   if (pkg) {
@@ -192,14 +201,22 @@ export async function injectManifest(
 
   await injectGitignore(chain, target)
 
-  if (!pkg) warnSkippedInstalls(chain, target)
+  if (!pkg) warnUnreadablePackage(chain, target)
 }
 
-function warnSkippedInstalls(chain: readonly Manifest[], target: string): void {
+/**
+ * Only an existing package.json that fails to parse reaches here with installs
+ * pending, since an absent one was written above. It is left untouched.
+ */
+function warnUnreadablePackage(
+  chain: readonly Manifest[],
+  target: string,
+): void {
+  if (!declaresInstalls(chain)) return
+
   const deps = collectDeps(chain, {}).map((dep) => dep.spec)
   const skipped = applyScripts({}, chain)
   const scripts = [...new Set([...skipped.added, ...skipped.overridden])]
-  if (deps.length === 0 && scripts.length === 0) return
 
   logStep('Skipped installs')
   if (deps.length > 0) {
@@ -208,5 +225,7 @@ function warnSkippedInstalls(chain: readonly Manifest[], target: string): void {
   if (scripts.length > 0) {
     logWarn(`Scripts not added: ${scripts.join(', ')}`)
   }
-  logWarn(`No package.json: run 'bun init' in ${target}, then sync again`)
+  logWarn(
+    `package.json is not valid JSON: fix it in ${target}, then sync again`,
+  )
 }

package/src/tooling/package.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs'
+import { basename } from 'node:path'
 import type { Manifest } from '@/tooling/manifest'
 
 export interface PackageJson {
@@ -28,6 +29,37 @@ export function readPackage(path: string): PackageJson | undefined {
   }
 }
 
+/**
+ * Whether the chain asks for any dev dependency or script, which is what makes
+ * a missing package.json worth writing. A stack that installs nothing, such as
+ * the one `canon claude` drives, leaves a project without a manifest alone.
+ */
+export function declaresInstalls(chain: readonly Manifest[]): boolean {
+  if (collectDeps(chain, {}).length > 0) return true
+
+  const scripts = applyScripts({}, chain)
+  return scripts.added.length > 0 || scripts.overridden.length > 0
+}
+
+/**
+ * The manifest a sync writes into a folder that has none. The name is the
+ * folder's, reduced to the characters npm accepts, so it is never empty or
+ * invalid.
+ */
+export function minimalPackage(target: string): PackageJson {
+  const name = basename(target)
+    .toLowerCase()
+    .replace(/[^a-z0-9-._]/g, '-')
+    .replace(/^[._]+/, '')
+    .slice(0, 214)
+
+  return {
+    name: name === '' ? 'project' : name,
+    version: '0.0.0',
+    type: 'module',
+  }
+}
+
 export function serializePackage(pkg: PackageJson): string {
   return `${JSON.stringify(pkg, null, 2)}\n`
 }

package/src/tooling/read.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { PROJECT_ROOT } from '@/roots/project'
+import { configFiles, type Manifest, seedFiles } from '@/tooling/manifest'
 
 /**
  * Spells the package root in a report where every other root spells a
@@ -11,6 +12,8 @@ import { PROJECT_ROOT } from '@/roots/project'
 const PACKAGE_LABEL = '<canon>'
 
 export interface ReferenceRoot {
+  /** The root whose `tooling/` this searches, as the manifest loader takes it. */
+  readonly root: string
   /** Absolute `tooling/` directory to search. */
   readonly dir: string
   /** How a report spells a copy found under this root. */
@@ -19,6 +22,8 @@ export interface ReferenceRoot {
 
 export interface ResolvedReference {
   readonly path: string
+  /** The root that won, so the manifest is read from the same copy. */
+  readonly root: string
   /** The label of the root that won, joined to the stack and filename. */
   readonly source: string
 }
@@ -36,8 +41,9 @@ function toolingSourceDir(root: string): string {
  */
 export function referenceRoots(root: string): ReferenceRoot[] {
   return [
-    { dir: toolingSourceDir(root), label: 'tooling' },
+    { root, dir: toolingSourceDir(root), label: 'tooling' },
     {
+      root: PROJECT_ROOT,
       dir: toolingSourceDir(PROJECT_ROOT),
       label: join(PACKAGE_LABEL, 'tooling'),
     },
@@ -49,10 +55,10 @@ export function resolveReference(
   root: string,
   stack: string,
 ): ResolvedReference | undefined {
-  for (const { dir, label } of referenceRoots(root)) {
+  for (const { root: owner, dir, label } of referenceRoots(root)) {
     const path = join(dir, stack, 'reference.md')
     if (existsSync(path)) {
-      return { path, source: join(label, stack, 'reference.md') }
+      return { path, root: owner, source: join(label, stack, 'reference.md') }
     }
   }
 
@@ -62,3 +68,40 @@ export function resolveReference(
 export function readReference(reference: ResolvedReference): string {
   return readFileSync(reference.path, 'utf8')
 }
+
+function codeList(items: readonly string[]): string {
+  return items.map((item) => `- \`${item}\``).join('\n')
+}
+
+/**
+ * The sections the verb prints after a stack's reference, read from its
+ * manifest so no reference keeps a hand list that drifts from it. A stack lists
+ * its own files and groups alone, since a parent's print under the parent's
+ * reference, and a section with nothing to list prints no heading.
+ */
+export function renderStackSections(manifest: Manifest): string {
+  const sections: string[] = []
+  const configs = configFiles(manifest)
+  const seeds = seedFiles(manifest)
+
+  if (configs.length > 0 || seeds.length > 0) {
+    const sync = ['## Sync']
+    if (configs.length > 0) {
+      sync.push('Sync keeps these current, from `configs/`:', codeList(configs))
+    }
+    if (seeds.length > 0) {
+      sync.push('Sync copies these once, from `seeds/`:', codeList(seeds))
+    }
+    sections.push(sync.join('\n\n'))
+  }
+
+  if (manifest.gitignore.length > 0) {
+    const groups = manifest.gitignore.map(
+      ({ header, entries }) =>
+        `- \`${header}\`: ${entries.map((entry) => `\`${entry}\``).join(', ')}`,
+    )
+    sections.push(`## Gitignore\n\n${groups.join('\n')}`)
+  }
+
+  return sections.map((section) => `\n${section}\n`).join('')
+}

package/src/tooling/scan.ts

@@ -12,6 +12,7 @@ import {
 import {
   collectDeps,
   collectScripts,
+  declaresInstalls,
   type DepState,
   readPackage,
   type ScriptState,
@@ -48,6 +49,7 @@ export interface ScanResult {
   readonly deps: readonly DepState[]
   readonly gitignore: readonly EntryState[]
   readonly hasPackageJson: boolean
+  readonly newManifest: boolean
   readonly totalChanges: number
 }
 
@@ -128,8 +130,10 @@ export function scan(chain: readonly Manifest[], target: string): ScanResult {
 
   const packagePath = join(target, 'package.json')
   const pkg = readPackage(packagePath)
-  const scripts = pkg ? collectScripts(chain, pkg) : []
-  const deps = pkg ? collectDeps(chain, pkg) : []
+  const newManifest = !existsSync(packagePath) && declaresInstalls(chain)
+  const basis = pkg ?? (newManifest ? {} : undefined)
+  const scripts = basis ? collectScripts(chain, basis) : []
+  const deps = basis ? collectDeps(chain, basis) : []
 
   const gitignorePath = join(target, '.gitignore')
   const gitignoreContent = existsSync(gitignorePath)
@@ -138,6 +142,7 @@ export function scan(chain: readonly Manifest[], target: string): ScanResult {
   const gitignore = scanGitignore(chain, gitignoreContent)
 
   const totalChanges =
+    (newManifest ? 1 : 0) +
     configs.filter((entry) => entry.state !== 'matching').length +
     seeds.filter((entry) => entry.state === 'missing').length +
     scripts.filter((entry) => entry.state !== 'matching').length +
@@ -152,6 +157,7 @@ export function scan(chain: readonly Manifest[], target: string): ScanResult {
     deps,
     gitignore,
     hasPackageJson: pkg !== undefined,
+    newManifest,
     totalChanges,
   }
 }