@erclx/canon 5.34.0 → 5.36.0

package/src/records/validate.ts

@@ -7,7 +7,6 @@ import {
   recordDir as resolveRecordDir,
   recordDirs as resolveRecordDirs,
 } from '@/roots/record'
-import { ATTRIBUTE_MARKER, governedPaths, readScope } from '@/standards/scope'
 import {
   TEACH_GLOSSARY,
   TEACH_MISSION,
@@ -18,34 +17,10 @@ import {
   WORKSPACE_NAME,
 } from '@/teach/workspace'
 
-export const RECORD_KINDS = [
-  'plans',
-  'groundwork',
-  'intake',
-  'standards',
-  'teach',
-] as const
+export const RECORD_KINDS = ['plans', 'groundwork', 'intake', 'teach'] as const
 
 export type RecordKind = (typeof RECORD_KINDS)[number]
 
-/**
- * The folders standards reads, in precedence order.
- *
- * It carries two because the corpus authors at the project root and installs
- * under `.claude/`. The authoring root wins where both exist, since the
- * installed tree is a generated copy here and a finding fixed there is
- * overwritten by the next regen. A project that consumed the corpus holds only
- * the second, so one order serves both.
- *
- * Every other kind is a session record and takes the record roots instead,
- * resolved by `@/roots/record`. Standards is the one kind that is tracked, so it
- * does not move and spells its own two candidates here.
- */
-const STANDARDS_FOLDERS: readonly string[] = [
-  'standards',
-  join('.claude', 'standards'),
-]
-
 /**
  * `unknown-kind` is raised at the argument boundary rather than by the walk, and
  * it sits here because both reach a caller through the same `reason` field. A
@@ -60,7 +35,6 @@ export const FINDING_KINDS = [
   'name-malformed',
   'title-missing',
   'section-missing',
-  'scope-unanchored',
   'entry-unreasoned',
   'suggestion-missing',
   'question-unanswerable',
@@ -103,10 +77,6 @@ export type ValidateOutcome = ValidateReport | ValidateRefused
 
 /** Every folder a kind would accept, whether or not it is on disk. */
 export function recordDirs(root: string, kind: RecordKind): string[] {
-  if (kind === 'standards') {
-    return STANDARDS_FOLDERS.map((folder) => join(root, folder))
-  }
-
   return resolveRecordDirs(root, kind)
 }
 
@@ -114,19 +84,8 @@ export function recordDirs(root: string, kind: RecordKind): string[] {
  * The folder a kind reads. The first candidate on disk wins, and the creation
  * default stands in when none exists, so a refusal and a test fixture both name
  * the location the kind would be written to.
- *
- * The default is where this parts company with `dirs[0]`, which the record
- * kinds can no longer take: their first candidate is the root the move lands at
- * and nothing creates there yet, so a fallback reading it would name a folder no
- * verb would ever write. Standards has no such split, since it is tracked and
- * its first candidate is where it is authored.
  */
 export function recordsDir(root: string, kind: RecordKind): string {
-  if (kind === 'standards') {
-    const dirs = recordDirs(root, kind)
-    return dirs.find((dir) => existsSync(dir)) ?? dirs[0]
-  }
-
   return resolveRecordDir(root, kind)
 }
 
@@ -134,18 +93,6 @@ export function isRecordKind(value: string): value is RecordKind {
   return (RECORD_KINDS as readonly string[]).includes(value)
 }
 
-/**
- * Whether a kind's folder is shared session scratch at the main worktree root.
- *
- * The five record folders are, so every session validates the records every
- * other session reads. The corpus is tracked instead, so a linked worktree holds
- * its own edited copy, and defaulting that kind to the main root would report on
- * a tree the session never touched and say nothing about which one it read.
- */
-export function isSharedScratch(kind: RecordKind): boolean {
-  return kind !== 'standards'
-}
-
 const NONE_IDENTIFIED = 'None identified.'
 const NUMBERED_FILE = /^\d{2}-[a-z0-9]+(-[a-z0-9]+)*\.md$/
 
@@ -920,127 +867,6 @@ async function checkWorkspace(dir: string, slug: string): Promise<Finding[]> {
   ]
 }
 
-const STANDARD_INDEX = 'index.md'
-const STANDARD_FIELDS = ['title', 'description'] as const
-
-const DOES_NOT_GOVERN = 'Does not govern:'
-
-/**
- * The words a governed path offers a filename. Each segment gives its own word
- * and, where it carries a prefix or a placeholder, the parts either side of a
- * hyphen, so `.canon/tasks/session-<slug>.md` offers `tasks` and `session`.
- *
- * A dotted segment gives nothing. It names the folder holding the artifact
- * rather than the artifact, and a standard named for it would pass this check
- * while naming the container every sibling shares.
- */
-export function pathWords(path: string): string[] {
-  const words: string[] = []
-
-  for (const segment of path.split('/')) {
-    if (segment.startsWith('.')) continue
-
-    const stem = segment.replace(/\.[a-z]+$/i, '').toLowerCase()
-    words.push(stem)
-    if (stem.includes('-')) words.push(...stem.split('-'))
-  }
-
-  return words.filter((word) => /^[a-z]+$/.test(word))
-}
-
-/**
- * Accepts the singular and the plural of one word. A standard over a single
- * document is named for the document and one over a folder of them is named for
- * either, and picking a side would report a conforming half of the corpus.
- */
-function namesWord(stem: string, word: string): boolean {
-  return stem === word || `${stem}s` === word || stem === `${word}s`
-}
-
-function checkStandardName(name: string, statement: string): Finding[] {
-  const paths = governedPaths(statement)
-
-  // The marker is read only where the first sentence backticks nothing, which
-  // is the catalog's own rule. A statement naming a path publishes that path
-  // however the rest of the statement describes itself.
-  if (paths.length === 0) {
-    if (statement.includes(ATTRIBUTE_MARKER)) return []
-
-    return [
-      finding(
-        'scope-unanchored',
-        name,
-        name,
-        'backticks no path in its first scope sentence and does not call itself an attribute standard, so it names no artifact to be named for.',
-      ),
-    ]
-  }
-
-  const stem = name.replace(/\.md$/, '')
-  const words = paths.flatMap(pathWords)
-
-  if (words.some((word) => namesWord(stem, word))) return []
-
-  return [
-    finding(
-      'name-malformed',
-      name,
-      name,
-      `names no part of ${paths.join(', ')}, which is what it governs. A rename reaches every target that installed the corpus and every surface citing it by bare filename.`,
-    ),
-  ]
-}
-
-export function checkStandard(name: string, text: string): Finding[] {
-  const findings: Finding[] = []
-  const frontmatter = parseFrontmatter(text)
-
-  const missing = STANDARD_FIELDS.filter(
-    (field) => !readField(frontmatter, field),
-  )
-
-  if (missing.length > 0) {
-    findings.push(
-      finding(
-        'frontmatter-incomplete',
-        name,
-        name,
-        `carries no ${missing.join(' and no ')}.`,
-      ),
-    )
-  }
-
-  const scope = readScope(text)
-
-  // The name derives from the scope statement, so an absent section leaves
-  // nothing to derive against. Reporting the name as well would name one defect
-  // twice and point the fix at the wrong file.
-  if (!scope) {
-    return [
-      ...findings,
-      finding(
-        'section-missing',
-        name,
-        '## Scope',
-        'is absent, so the standard claims no jurisdiction and can refuse no rule.',
-      ),
-    ]
-  }
-
-  if (!scope.lines.some((line) => line.trim().startsWith(DOES_NOT_GOVERN))) {
-    findings.push(
-      finding(
-        'section-missing',
-        name,
-        DOES_NOT_GOVERN,
-        'is absent from the scope section, so no boundary names the owner it hands off to.',
-      ),
-    )
-  }
-
-  return [...findings, ...checkStandardName(name, scope.statement)]
-}
-
 /**
  * The three kinds whose records are folders rather than files. Keyed by kind so
  * a seventh arrives as an entry here and the compiler names the walk it owes,
@@ -1048,7 +874,7 @@ export function checkStandard(name: string, text: string): Finding[] {
  */
 const FOLDER_CHECK: Readonly<
   Record<
-    Exclude<RecordKind, 'plans' | 'standards'>,
+    Exclude<RecordKind, 'plans'>,
     (dir: string, slug: string) => Promise<Finding[]>
   >
 > = {
@@ -1066,9 +892,8 @@ async function validateFiles(
   dir: string,
   kind: RecordKind,
   check: (name: string, text: string) => Finding[],
-  skip: (file: string) => boolean = () => false,
 ): Promise<ValidateReport> {
-  const files = (await listMarkdown(dir)).filter((file) => !skip(file))
+  const files = await listMarkdown(dir)
 
   const perFile = await Promise.all(
     files.map(async (file) =>
@@ -1080,12 +905,9 @@ async function validateFiles(
 }
 
 /**
- * Reports what every record in one folder claims against the shape its standard
- * fixes. It writes nothing whichever kind runs, and the reason differs by kind.
- * A session record is per-machine scratch with no history behind it, so a repair
- * that guessed wrong could not be undone. A standard installs into every target
- * and is cited by bare filename, so a rename costs more than the file move it
- * looks like.
+ * Reports what every record in one folder claims against the shape its reference
+ * fixes. It writes nothing, since a session record is per-machine scratch with
+ * no history behind it, so a repair that guessed wrong could not be undone.
  */
 export async function validateRecords(
   root: string,
@@ -1102,16 +924,6 @@ export async function validateRecords(
 
   if (kind === 'plans') return validateFiles(dir, kind, checkPlan)
 
-  // The walk stays flat, matching install and the catalog.
-  if (kind === 'standards') {
-    return validateFiles(
-      dir,
-      kind,
-      checkStandard,
-      (file) => file === STANDARD_INDEX,
-    )
-  }
-
   const folders = await listFolders(dir)
   const check = FOLDER_CHECK[kind]
   const perFolder = await Promise.all(

package/src/sandbox/provision.ts

@@ -220,11 +220,6 @@ function install(
   fail(`Could not install ${label} into the sandbox.`)
 }
 
-/**
- * No standards install. The corpus installs into no target, so a scenario
- * driving a skill that reads one takes the `canon standards <name>` path a real
- * project takes.
- */
 function setupAssets(
   root: string,
   sandbox: string,

package/src/secrets/shipped.ts

@@ -13,8 +13,7 @@ import { join } from 'node:path'
  *
  * What it does not cover is the plugin, which a marketplace install reads live
  * from `claude/` rather than from a tarball. That folder is a `files` entry
- * too, and its `standards` symlink resolves into a tree the field lists in its
- * own right, so both routes land inside the same corpus.
+ * too, so both routes land inside the same corpus.
  */
 export type ShipEntries =
   /** The field declares a corpus, which is what this check reads. */

package/src/serve/static.ts

@@ -200,8 +200,7 @@ export function resolveWithin(
 /**
  * Re-tests containment after following symlinks. `resolveWithin` is lexical
  * and `resolve` does not follow a link, so a link inside the root clears that
- * test while the file it points at sits outside. This repository is a live
- * instance, since `claude/standards` is a link out of `claude/`.
+ * test while the file it points at sits outside.
  *
  * Only a path that exists is checked, because a link can be followed only once
  * there is something on the other end, and a path that resolves to nothing is

package/src/shipped/references.ts

@@ -10,8 +10,7 @@ import { isMarked } from '@/sweep/exempt-marker'
  * on purpose rather than by omission. What decides membership here is whether
  * anything serves the file to a reader who does not hold this repository: a
  * skill body loads into a session, a docs page is read through `canon docs`, a
- * standard through `canon standards`, a rule through a glob match, and a seed
- * through an install. A `src/` doc comment
+ * rule through a glob match, and a seed through an install. A `src/` doc comment
  * is read by someone working on the toolkit, in this checkout, where every
  * number resolves.
  *
@@ -19,18 +18,12 @@ import { isMarked } from '@/sweep/exempt-marker'
  * `src/design/base.css` and `src/design/tokens.ts` carry sixteen values shaped
  * `#191512`, which no width or boundary rule separates from a pull request
  * number, so telling them apart would need the line's syntactic position.
- *
- * `claude/standards` is a symlink into one of the roots below, and a walk that
- * followed it would read that corpus twice and report every finding in it
- * under two paths. Nothing is lost by not following, since it is a corpus here
- * in its own right.
  */
 export const SHIPPED_CORPORA = [
   'claude',
   'docs',
   'governance',
   'scripts',
-  'standards',
   'tooling',
 ] as const
 
@@ -61,7 +54,7 @@ export const REFERENCE_MARKER = 'canon-allow-reference'
  * already ships `anthropics/claude-code#58345` in exactly that form.
  *
  * The trailing boundary is what the first shape of this pattern lacked, and it
- * costs a live finding to omit. `governance/rules/framework/250-tailwind.md`
+ * costs a live finding to omit. `governance/rules/framework/tailwind.md`
  * writes `bg-[#316ff6]`, a Tailwind arbitrary hex color, which an unbounded
  * `#[0-9]+` reads as pull request 316. Requiring a non-word character after the
  * digits rejects it and rejects nothing real, since a citation is always
@@ -146,37 +139,15 @@ const SAME_REPOSITORY =
 const DOCS_PATH = /(?<![\w./-])docs\/[^\s`)\]]*\.md\b/g
 
 /**
- * A bare `standards/<name>.md` citation from a body under `claude/skills/`,
- * which `598-authoring-layout.md` fixes as the broken form there:
- * `${CLAUDE_SKILL_DIR}` is what resolves off the `claude/standards` symlink
- * in every plugin cache, and a raw path has nothing to expand it.
- *
- * Scoped to that one corpus rather than every `isShippedCorpus` reads,
- * because `docs/agents/` and `docs/workflow/` carry the identical
- * `standards/<name>.md` shape correctly: a docs page resolves from this
- * checkout's own root rather than through a skill's `${CLAUDE_SKILL_DIR}`,
- * so the same string is the fix in one corpus and the defect in the other.
- * Widening the pattern to every corpus turns it into a mass false-positive
- * over the dozens of correct citations those two folders carry.
- *
- * The same leading-boundary discipline as `DOCS_PATH` excludes the already
- * correct form: a `/` sits ahead of `standards` in
- * `${CLAUDE_SKILL_DIR}/../../standards/<name>.md`, which the negative
- * lookbehind rejects, so a citation already rewritten to the resolving form
- * does not fail this check a second time.
+ * A call to `canon standards`, a verb no installed CLI carries any more. A
+ * shipped body naming it sends a target reader to an unknown-command error,
+ * so every corpus reports it, `docs/` included. A page saying the verb is gone
+ * carries the reference marker on that line.
  *
- * Reported unless `isStandardsPathReportable` reads the match as a
- * deliberate placeholder rather than a real citation. A body illustrating
- * the shape a project's own `standards/<name>.md` takes writes a bracketed
- * token this pattern also matches, such as `standards/<slug>.md`
- * in a skill that drafts one, which names no real file. A bare,
- * non-bracketed match now reports whether or not the file exists, unlike
- * `DOCS_PATH`, which still gates on existence: a same-repository citation
- * under this corpus names no target project's own tree the way a `docs/`
- * path can, so shape alone separates a placeholder from a broken citation
- * here with no false-positive class existence was catching.
+ * The trailing lookahead keeps a hyphenated token such as a `standards-audit`
+ * page name from matching, since that names a file rather than a call.
  */
-const STANDARDS_PATH = /(?<![\w./-])standards\/[^\s`)\]]*\.md\b/g
+const STANDARDS_CALL = /\bcanon standards(?![\w-])/g
 
 /**
  * A phase-label-shaped token: exactly two numeric groups, with a negative
@@ -200,20 +171,20 @@ const STANDARDS_PATH = /(?<![\w./-])standards\/[^\s`)\]]*\.md\b/g
 const PHASE_LABEL = /\bv\d+\.\d+(?!\.\d)\b/g
 
 /**
- * A `.claude/rules/<segments>/<nnn>-<slug>.md` citation from a body under
- * `claude/skills/`, the installed-path spelling `598-authoring-layout.md`
- * bans a shipped skill body from citing as authority for its own behavior.
+ * A `.claude/rules/<segments>/<slug>.md` citation from a body under
+ * `claude/skills/`, the installed-path spelling `authoring-layout.md` bans a
+ * shipped skill body from citing as authority for its own behavior.
  *
- * Anchored on the trailing `\d{3}-[\w-]+\.md` rather than on the bare
- * `.claude/rules/` prefix, which is what keeps a folder mention carrying no
- * number, such as `create-rule`, `target-check`, and `target-setup` already
- * write correctly, from matching. The segment group between `rules/` and the
- * numbered file admits both a governance-namespace path
- * (`canon/canon/604-scratch.md`) and a project-namespace one
- * (`project/<subdir>/<n>-<slug>.md`) without distinguishing them, since
- * either shape is the same broken citation.
+ * Anchored on a trailing `.md` file rather than on the bare `.claude/rules/`
+ * prefix, which is what keeps a folder mention, such as `create-rule`,
+ * `target-check`, and `target-setup` write, from matching: it ends in `/` or
+ * names no `.md`. The segments between `rules/` and the file admit both a
+ * governance-namespace path (`canon/canon/scratch.md`) and a
+ * project-namespace one (`project/<subdir>/<slug>.md`) without distinguishing
+ * them, since either shape is the same broken citation, and the placeholder
+ * check spares the bracketed illustration.
  */
-const RULE_PATH = /(?<![\w./-])\.claude\/rules\/[^\s`)\]]*\/\d{3}-[\w-]+\.md\b/g
+const RULE_PATH = /(?<![\w./-])\.claude\/rules\/[^\s`)\]]*?[\w-]+\.md\b/g
 
 export interface ShippedReference {
   readonly file: string
@@ -223,7 +194,7 @@ export interface ShippedReference {
     | 'pull-request'
     | 'commit'
     | 'docs-path'
-    | 'standards-path'
+    | 'retired-verb'
     | 'phase-label'
     | 'rule-path'
   /** The reference as written, so a report names the token to qualify. */
@@ -272,50 +243,31 @@ function isDocsPathReportable(
 }
 
 /**
- * Whether `file` sits in the one corpus `STANDARDS_PATH` and `RULE_PATH`
- * both gate: a shipped skill body, minus its own `REQUIREMENT.md`.
+ * Whether `file` sits in the one corpus `RULE_PATH` gates: a shipped skill
+ * body, minus its own `REQUIREMENT.md`.
  *
- * Both patterns share this scope because both bans live in
- * `598-authoring-layout.md`, stated for the same reader: a session loading
- * the `SKILL.md` body a target actually receives. `REQUIREMENT.md` is
- * excluded for the reason that file states there, since a maintainer or an
- * audit command reads it rather than a session loading it, so neither
- * resolver rule this pair enforces ever applies to it. One predicate serves
- * both call sites rather than two copies drifting apart with nothing
- * comparing them.
+ * The ban lives in `authoring-layout.md`, stated for one reader: a
+ * session loading the `SKILL.md` body a target actually receives.
+ * `REQUIREMENT.md` is excluded for the reason that file states there, since a
+ * maintainer or an audit command reads it rather than a session loading it,
+ * so the resolver rule never applies to it.
  */
 function isSkillBodyScope(file: string): boolean {
   return file.startsWith('claude/skills/') && !file.endsWith('/REQUIREMENT.md')
 }
 
-/**
- * Whether a `STANDARDS_PATH` match should be reported: every match that is
- * not a placeholder, whether or not the named file exists.
- *
- * Existence used to gate this the same way `isDocsPathReportable` gates its
- * corpus, which conflated a deliberate placeholder with a genuinely broken,
- * real-looking citation: both fail existence and both passed muted. A bare
- * `standards/<name>.md` names no target-project tree the way a `docs/` path
- * can, so shape alone separates the two classes here with no false-positive
- * class existence was catching.
- */
-function isStandardsPathReportable(path: string): boolean {
-  return !isPlaceholderPath(path)
-}
-
 /**
  * Every reference in one shipped file that no marker mutes.
  *
  * The corpus walk is deliberately absent, which lets most of the shape be
  * tested against a string rather than against a fixture. That is the seam
  * `headingCitationsIn` draws in `src/claude/skills-headings.ts` and `citationsIn`
- * draws in `skills-reach.ts`. `DOCS_PATH` and `STANDARDS_PATH` are the two
- * patterns that still need a filesystem, since resolving against this
- * checkout is the only thing that separates a real citation from an
- * illustration for either, so `referencesIn` takes `root` as the one
- * caller-supplied exception to that rule. `root` is required rather than
- * defaulted, since a caller that dropped it silently would report zero
- * findings for both rather than raising, which is the wrong failure
+ * draws in `skills-reach.ts`. `DOCS_PATH` is the one pattern that still
+ * needs a filesystem, since resolving against this checkout is the only thing
+ * that separates a real citation from an illustration, so `referencesIn`
+ * takes `root` as the one caller-supplied exception to that rule. `root` is
+ * required rather than defaulted, since a caller that dropped it silently
+ * would report zero findings rather than raising, which is the wrong failure
  * direction for a gate.
  *
  * The unit is the match rather than the line, unlike those two, because one
@@ -375,16 +327,13 @@ export function referencesIn(
       })
     }
 
-    if (isSkillBodyScope(file)) {
-      for (const match of line.matchAll(STANDARDS_PATH)) {
-        if (!isStandardsPathReportable(match[0])) continue
-        references.push({
-          file,
-          line: index + 1,
-          kind: 'standards-path',
-          text: match[0],
-        })
-      }
+    for (const match of line.matchAll(STANDARDS_CALL)) {
+      references.push({
+        file,
+        line: index + 1,
+        kind: 'retired-verb',
+        text: match[0],
+      })
     }
 
     for (const match of line.matchAll(PHASE_LABEL)) {

package/src/sync/check.ts

@@ -3,9 +3,10 @@ import { basename, join, sep } from 'node:path'
 import { execa } from 'execa'
 import { gitEnv } from '@/git/env'
 import { createDesignAdapter, DESIGN_INSTALL_DIR } from '@/design/adapter'
-import { createGovAdapter, rulesSourceDir } from '@/gov/adapter'
+import { createGovAdapter } from '@/gov/adapter'
 import { successorResolver } from '@/gov/renames'
-import { loadGovStack, resolveMissingRules, resolveRules } from '@/gov/stacks'
+import { lookupRules } from '@/gov/install'
+import { resolveMissingRules, resolveRules } from '@/gov/stacks'
 import { planSync, type ScanEntry, type SyncAdapter } from '@/sync/engine'
 import {
   collectSuperseded,
@@ -576,7 +577,8 @@ export function readInstalledRules(
  * not already hold.
  *
  * The band test is the entitlement filter, and `bands` carries two sources: the
- * folders the target already holds, and the folders the base stack takes whole.
+ * folders the target already holds, and the folders holding a rule the base
+ * stack resolves to.
  * A rule authored under `lang/` or `ui/` is named by an individual stack, so it
  * belongs to some targets and not others, and listing every added file would
  * tell a base consumer about rules it was never entitled to. The test
@@ -615,27 +617,29 @@ export function selectNewRules(
 }
 
 /**
- * Band folders the base stack takes whole. Every governance stack extends base,
- * so a rule authored under one of these is entitled to every target.
+ * Band folders holding a rule the base stack resolves to. Every governance
+ * stack extends base, so a new rule authored beside one of base's rules is
+ * reported to every target the fallback below reads.
  *
  * This is what covers a band no target can carry yet. Entitlement is otherwise
- * read off folders the target already holds, and a folder added to base later
+ * read off folders the target already holds, and a band base reaches later
  * exists in no installed tree, so without this the rules inside it would reach
- * nobody. Read from the stack file rather than fixed, so that addition needs no
- * code change here.
+ * nobody. Read through `resolveRules` rather than off the stack's entries,
+ * since base names its rules one by one and an entry is a slug rather than a
+ * folder.
  *
- * A folder only a leaf stack names is deliberately absent. It is entitled to
+ * A folder only a leaf stack reaches is deliberately absent. It is entitled to
  * some targets and not others, which is the distinction the band test makes and
  * the installed tree is the only evidence of.
  */
 export function baseBands(root: string): Set<string> {
-  const stack = loadGovStack(root, 'base')
-  if (stack === undefined) return new Set()
+  const resolution = resolveRules(root, 'base')
+  if (!resolution.ok) return new Set()
 
   return new Set(
-    stack.rules.filter((entry) =>
-      isDirectory(join(rulesSourceDir(root), entry)),
-    ),
+    lookupRules(root, resolution.rules)
+      .found.map((source) => source.subdir.split(sep)[0] ?? '')
+      .filter((band) => band !== ''),
   )
 }
 

package/src/sync/copy.ts

@@ -4,11 +4,10 @@ import { dirname } from 'node:path'
 /**
  * Copies with `cp` semantics. Two behaviors matter and neither is the default
  * in the obvious alternatives. `Bun.write` drops the executable bit, which
- * would land husky hooks and `scripts/verify.sh` non-executable. Plain
- * `copyFile` imposes the source mode on an existing destination, so a file the
- * target deliberately restricted to 600, or an earlier stack set executable,
- * comes back at the source's mode. `cp` leaves an existing destination's mode
- * alone.
+ * would land husky hooks non-executable. Plain `copyFile` imposes the source
+ * mode on an existing destination, so a file the target deliberately
+ * restricted to 600, or an earlier stack set executable, comes back at the
+ * source's mode. `cp` leaves an existing destination's mode alone.
  *
  * Every domain that writes into a target routes through here. The tooling
  * inject path found the trap first, and the sync engine inherits it for every