@erclx/aitk 0.37.0 → 0.39.0

package/claude/skills/toolkit-triage/REQUIREMENT.md

@@ -0,0 +1,40 @@
+---
+name: toolkit-triage
+description: Why the feedback queue is read from GitHub rather than local scratch, and why triage routes instead of implementing
+---
+
+# Toolkit triage requirement
+
+## Gap
+
+Without this skill, the feedback queue fills and nothing drains it. Reports arrive from projects the toolkit never sees, and a queue nobody reads on a schedule is the same as no queue. The local review folder looks like the right place to read, and it is the wrong one, because that content is per-machine session scratch that any cleanup removes.
+
+Triage fails three ways once it starts. Unrelated issues get batched into one branch, so review has to judge several unconnected changes at once and can approve none of them cleanly. An issue needing a plan gets implemented inline from a paragraph of description, which skips the step where scope is argued. And an issue whose report contradicts itself gets a guess rather than a question, so the fix addresses a defect nobody confirmed.
+
+The queue also fails to drain even when the work ships. A fix merged with no link back leaves its issue open, and the next triage re-reads work already done.
+
+## Must
+
+- Read the durable queue rather than local session scratch
+- Classify each issue in a fixed order and stop at the first match, stating the class and its one-line reason before routing
+- Route to the skills that own planning, branch naming, and the pull request body rather than restating them
+- Keep one issue to one branch and one pull request
+- Link a fix to its issue so merge closes it, and preserve that link when the body is regenerated
+- Ask on the issue when the report is unreadable, then move on rather than blocking the batch
+
+## Must not
+
+- Batch unrelated fixes into one branch
+- Implement a plan-worthy issue, which stops at the plan handed back to the user
+- Close an issue whose pull request has yet to merge
+
+## Guards
+
+- The `gh` CLI absent or unauthenticated stops, since the queue is unreachable
+- An empty queue reports nothing open rather than widening the label to find work
+
+## Out of scope
+
+- Filing new feedback: `toolkit-feedback`
+- Writing the plan a plan-worthy issue needs: `claude-feature`
+- Triage of issues carrying any other label, which surface here by design only under the feedback label

package/claude/skills/youtube-transcripts/REQUIREMENT.md

@@ -0,0 +1,38 @@
+---
+name: youtube-transcripts
+description: Why the transcript fetch stays in the CLI, and why fetching stops short of reading
+---
+
+# Youtube transcripts requirement
+
+## Gap
+
+Without this skill, a pasted video link turns into captions printed in chat, which persist nowhere and cannot be cited by a later session. The file is the point. A transcript saved with its metadata is context the repository holds, and a transcript in a message is context that ends with the turn.
+
+A session that fetches on its own gets the shape wrong. Raw captions carry timing cues and duplicated lines, and a file written without frontmatter has no title, no source URL, and no way to tell which video it came from. Reimplementing the cleanup also duplicates logic the CLI already owns, so the two drift and the drift shows up as inconsistent files rather than as an error.
+
+Two smaller failures follow the fetch. A video with no captions produces a file that looks empty rather than one reported as having none, so the user reads it as a failed fetch. And a session that summarizes what it fetched answers a question nobody asked, spending context on a reading the user may not want yet.
+
+## Must
+
+- Run the CLI, which owns the fetch, the caption cleanup, and the frontmatter
+- Surface the written path as a full relative path so the terminal makes it clickable
+- Report a video with no captions as a fact about the video, since the file still exists and carries its metadata
+- Name the missing external binary and stop, leaving the install to the user
+
+## Must not
+
+- Reimplement the fetch or the cleanup
+- Summarize or annotate the transcript unasked, which is a separate request against the file
+- Install the external binary the command shells out to
+
+## Guards
+
+- No URL stops, since there is nothing to fetch
+- A link that is not a YouTube URL stops rather than attempting a generic fetch the command cannot do
+
+## Out of scope
+
+- Downloading the video or its audio
+- Summarizing a transcript already on disk, which is a read of that file
+- Choosing where transcripts live, which the command defaults and a flag overrides

package/docs/agents.md

@@ -377,16 +377,21 @@ aitk context audit
 aitk context audit --json
 aitk context audit --citations-only
 aitk context audit --folder context,diagrams
+aitk context audit --folder docs
 ```
 
-| Option             | Behavior                                                                 |
-| ------------------ | ------------------------------------------------------------------------ |
-| `--json`           | Add a machine-readable record on stdout, keeping the frame               |
-| `--folder <list>`  | Comma-separated folder names under `.claude/` (default: the three below) |
-| `--citations-only` | Run the gating citation check alone, printing nothing when it passes     |
+| Option             | Behavior                                                             |
+| ------------------ | -------------------------------------------------------------------- |
+| `--json`           | Add a machine-readable record on stdout, keeping the frame           |
+| `--folder <list>`  | Comma-separated folder names (default: the three below)              |
+| `--citations-only` | Run the gating citation check alone, printing nothing when it passes |
 
 Scope defaults to `context`, `diagrams`, and `wireframes`, and a folder the project does not carry is skipped rather than reported. A domain that outgrew one file and split into `<domain>/` is audited as its own folder, so a split entry measures at the same grain as a flat one.
 
+A name passed to `--folder` resolves under `.claude/` first and at the project root second, which is what puts `docs/` and any later corpus in reach of the same engine. The root base is reached only by a name the caller passes, so the default list still resolves under `.claude/` alone and a project holding a root `wireframes/` is not audited against a standard it never adopted. The scope line prints the resolved path, so a project carrying both spellings reads which one was taken. The JSON record carries the base per folder as `folders[].base`.
+
+A run where no requested name resolves refuses, whichever list it read. Naming the absent ones narrows to `--folder`, since a project carrying one of the three default folders is the ordinary case and a name it never asked for is not a typo. The JSON record carries those names as `unresolvedFolders`.
+
 Exit codes are `0` for a clean run, `1` for a refusal, and `2` for an unresolved citation. Only the citation check sets a failing code. Required-section, length, depth, bullet weight, table, provenance, and index findings print and return `0`, because each is a judgment and failing a push on one would make the check something to route around.
 
 ### What each check reports
@@ -419,6 +424,8 @@ Three exclusions keep it from firing on prose about paths. Fenced blocks are ski
 
 What remains is a sentence naming a hypothetical entry to show the shape of a name, which no syntax separates from a real reference. Append `<!-- audit-ignore-citations -->` to that source line. The marker suppresses citation checking for its own line only.
 
+The pattern spells the `.claude/` prefix, so a folder resolved at the project root is measured by every other check and contributes nothing here. Widening it to a bare `docs/x.md` would match prose that references nothing, which is a separate decision from where entries come from. A run whose folders all resolved at the root says the check is out of scope rather than reporting that zero paths resolved, and the same run under `--citations-only` refuses, because a gate exiting clean on a scope it could not build is the failure the gate exists to catch.
+
 ## Runtime catalogs
 
 Use these to discover what's available instead of hardcoding names.
@@ -459,10 +466,11 @@ one malformed file cannot hide the rest of the catalog. `--names` emits skill
 names one per line.
 
 Each entry also carries `requirement`, whether the folder holds a sibling
-`REQUIREMENT.md`. Coverage of that file is selective by design, so a `false` is
-not a gap to close and the flag answers which skills carry one without a caller
-listing the directory itself. It says nothing about why, which is a judgment the
-toolkit records against its own corpus rather than in the catalog.
+`REQUIREMENT.md`. Every skill is meant to carry one, so a `false` is a gap to
+close rather than a recorded exemption, and the flag answers which skills are
+missing theirs without a caller listing the directory itself. Nothing gates the
+rule yet, which is why the flag is worth reading against the shipped corpus after
+a merge.
 
 ## Non-interactive examples
 

package/docs/operating-model.md

@@ -104,4 +104,4 @@ port-collision detail.
 
 - [Claude Code and git worktrees](../wiki/claude-worktrees.md) for the isolation and fan-out mechanics
 - [Claude Code subagents](../wiki/claude-subagents.md) for in-session parallelism without worktrees
-- `.claude/context/claude-plugin/skills.md` for how the skills in the loop are categorized
+- `.claude/context/claude-plugin/skill-strategy.md` for how the skills in the loop are categorized

package/docs/visual-design-workflow.md

@@ -130,7 +130,7 @@ Zero or one yes: tier 0. Two or three: tier 1. Four: tier 2. Resist over-tiering
 
 - [Stitch](../wiki/stitch.md): Gemini-powered design product with the MCP server that anchors tier 1
 - [Claude Design](../wiki/claude-design.md): first-party hosted design product and handoff bundle
-- `.claude/context/claude-plugin/skills.md`: how to decide between workflow and domain-knowledge skills
+- `.claude/context/claude-plugin/skill-strategy.md`: how to decide between workflow and domain-knowledge skills
 - [Visual wireframes](../wiki/visual-wireframes.md): Excalidraw research and setup for the tier 1 wireframe companion
 - [Community skills and plugins](../wiki/community-skills.md): catalog of frontend design skills and integrations
 - [Community MCP servers](../wiki/community-mcp-servers.md): catalog of MCPs referenced across all tiers

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/aitk",
   "type": "module",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/scripts/manage-sandbox.sh

@@ -296,6 +296,10 @@ inject_changed_skills() {
   [ -z "$combined" ] && return
 
   while IFS= read -r skill_path; do
+    # The diff against main lists a deleted skill alongside a changed one, and
+    # there is nothing left to inject for a name this branch removed.
+    [ -f "$PROJECT_ROOT/$skill_path" ] || continue
+
     local skill_name
     skill_name=$(basename "$(dirname "$skill_path")")
     local target_dir="$SANDBOX/.claude/skills/$skill_name"

package/src/commands/context.ts

@@ -59,7 +59,10 @@ export function register(program: Command): void {
     .argument('[path]', 'Project root, defaulting to the current directory')
     .helpOption('-h, --help', 'Show this help message')
     .option('--json', 'Add a machine-readable record on stdout')
-    .option('--folder <list>', `Comma-separated folder names under .claude/`)
+    .option(
+      '--folder <list>',
+      'Comma-separated folder names, resolved under .claude/ then the project root',
+    )
     .option('--citations-only', 'Run the gating citation check alone')
     .addHelpText(
       'after',
@@ -78,6 +81,7 @@ export function register(program: Command): void {
         '  aitk context audit --json',
         '  aitk context audit --citations-only',
         '  aitk context audit --folder context,diagrams',
+        '  aitk context audit --folder docs',
         '',
       ].join('\n'),
     )
@@ -96,11 +100,11 @@ function parseFolders(list: string | undefined): string[] | string {
 
   if (names.length === 0) return 'Empty --folder list. Pass at least one name.'
 
-  // `..` would resolve the audited folder above `.claude/`, taking the scan
-  // and the citation pattern outside the tree the audit describes.
+  // `..` would resolve the audited folder above the project root, taking the
+  // scan and the citation pattern outside the tree the audit describes.
   const invalid = names.filter((name) => !FOLDER_NAME.test(name))
   if (invalid.length > 0) {
-    return `--folder takes folder names under .claude/, not paths: ${invalid.join(', ')}`
+    return `--folder takes folder names, not paths: ${invalid.join(', ')}`
   }
 
   return names
@@ -116,15 +120,38 @@ async function runAudit(
 
   if (typeof names === 'string') return refuse(names, gateOnly)
 
-  const folders = await resolveFolders(root, names)
+  // The root base is opt-in. A target carrying a root `wireframes/` would
+  // otherwise be audited against a standard it never adopted, on a bare run
+  // that named nothing.
+  const named = opts.folder !== undefined
+  const { folders, missing } = await resolveFolders(root, names, {
+    canResolveAtRoot: named,
+  })
   if (folders.length === 0) {
     return refuse(
-      `No audited folder found under .claude/. Looked for: ${names.join(', ')}.`,
+      `No audited folder found ${named ? 'under .claude/ or the project root' : 'under .claude/'}. Looked for: ${names.join(', ')}.`,
       gateOnly,
     )
   }
 
-  const citations = await auditCitations(root, presentNames(folders))
+  // A default folder a project does not carry is the ordinary case and stays
+  // silent. A name passed by hand that resolves nowhere is a typo, and the run
+  // measuring the names that did resolve reads as a pass against a folder it
+  // never opened.
+  const unresolved = named ? missing : []
+
+  // The gate runs one check. Letting it exit 0 against a scope it could not
+  // build reports a pass on nothing measured, which is the outcome a gate is
+  // there to prevent.
+  const cited = presentNames(folders)
+  if (gateOnly && cited.length === 0) {
+    return refuse(
+      `The citation check spells the .claude/ prefix and no audited folder resolved there. Looked for: ${names.join(', ')}.`,
+      gateOnly,
+    )
+  }
+
+  const citations = await auditCitations(root, cited)
   if (citations.kind === 'unavailable') {
     return refuse(
       'git could not list the tree, so no citation was checked. Run inside a git repository.',
@@ -140,8 +167,8 @@ async function runAudit(
     reportGate(citations)
   } else {
     intro('aitk context audit')
-    reportScope(folders)
-    reportCitations(citations)
+    reportScope(folders, unresolved)
+    reportCitations(citations, cited)
     reportSections(sections, folders)
     reportLength(entries)
     reportDepth(entries)
@@ -158,9 +185,11 @@ async function runAudit(
         root,
         folders: folders.map((folder) => ({
           path: folder.rel,
+          base: folder.base,
           entries: folder.entries.length,
           governsContent: governsContent(folder),
         })),
+        unresolvedFolders: unresolved,
         citations: {
           scanned: citations.scanned,
           total: citations.total,
@@ -228,18 +257,54 @@ function plural(count: number, noun: string): string {
   return `${count} ${noun}${count === 1 ? '' : 's'}`
 }
 
-function reportScope(folders: readonly AuditedFolder[]): void {
+/**
+ * Names the resolved path of every audited folder, plus the requested names
+ * that resolved nowhere.
+ *
+ * The path is what says which base a name was taken from, which matters once a
+ * name can resolve under `.claude/` or at the project root and a project may
+ * carry both.
+ */
+function reportScope(
+  folders: readonly AuditedFolder[],
+  unresolved: readonly string[],
+): void {
   logStep('Scope')
 
   for (const folder of folders) {
     logInfo(`${folder.rel}: ${folder.entries.length} entries`)
   }
+
+  if (unresolved.length === 0) return
+
+  logWarn(
+    `Under neither .claude/ nor the project root: ${unresolved.join(', ')}`,
+  )
 }
 
 type ScannedCitations = Extract<CitationReport, { kind: 'scanned' }>
 
-function reportCitations(report: ScannedCitations): void {
+/**
+ * States the reach before the count, for the reason the provenance report
+ * states its own.
+ *
+ * A run auditing a folder at the project root builds no pattern, and a count of
+ * zero followed by a line saying every path resolves is indistinguishable from
+ * a corpus that cites nothing.
+ */
+function reportCitations(
+  report: ScannedCitations,
+  cited: readonly string[],
+): void {
   logStep('Citations')
+
+  if (cited.length === 0) {
+    logInfo(
+      'Out of scope. The pattern spells the .claude/ prefix, and no audited folder resolved there.',
+    )
+    return
+  }
+
   logInfo(
     `${plural(report.total, 'cited path')} across ${plural(report.scanned, 'file')}, fixtures and fenced examples excluded`,
   )

package/src/context/folders.ts

@@ -17,6 +17,12 @@ export const DEFAULT_FOLDERS: readonly string[] = [
   'wireframes',
 ]
 
+/** The base every folder in the default list sits under. */
+const CLAUDE_BASE = '.claude'
+
+/** The project root, reached only by a name the caller asked for. */
+const ROOT_BASE = '.'
+
 export interface AuditedFolder {
   /**
    * The requested folder name this was resolved under, which is what says
@@ -25,6 +31,11 @@ export interface AuditedFolder {
    * `.claude/context/claude-plugin` is governed as `context`.
    */
   readonly name: string
+  /**
+   * The base the name resolved under, which is what says whether the folder is
+   * in the citation check's scope.
+   */
+  readonly base: string
   /** Repo-relative folder path, used verbatim in every report line. */
   readonly rel: string
   readonly indexPath: string
@@ -43,16 +54,28 @@ export interface AuditedFolder {
 }
 
 /**
- * Names the requested folders that actually exist, which is the citation
- * check's scope.
+ * Names the requested `.claude/` folders that actually exist, which is the
+ * citation check's scope.
  *
  * A skill or seed pointing into `.claude/wireframes/` is a live instruction for
  * a project that carries the folder and says nothing about one that does not.
  * Checking a path into an absent folder would fail eight shipped references
  * here for the sole reason that this repository has no wireframes.
+ *
+ * A folder resolved at the project root is measured and stays out of this. The
+ * pattern the citation check builds spells the `.claude/` prefix, so admitting
+ * a root name there would check `.claude/<name>/` paths the audit never read.
+ * Widening the pattern to the root spelling is a separate change, since a bare
+ * `docs/x.md` appears in prose that references nothing.
  */
 export function presentNames(folders: readonly AuditedFolder[]): string[] {
-  return [...new Set(folders.map((folder) => folder.name))]
+  return [
+    ...new Set(
+      folders
+        .filter((folder) => folder.base === CLAUDE_BASE)
+        .map((folder) => folder.name),
+    ),
+  ]
 }
 
 async function readEntries(dir: string): Promise<string[]> {
@@ -70,6 +93,40 @@ async function readEntries(dir: string): Promise<string[]> {
   return paths.sort()
 }
 
+export interface FolderResolution {
+  /** Every folder that resolved, with the nested splits beneath each. */
+  readonly folders: readonly AuditedFolder[]
+  /**
+   * Requested names that resolved under no base, reported rather than dropped.
+   * Which absences are worth saying out loud is the caller's judgment: a
+   * default folder a project does not carry is ordinary, and a name passed by
+   * hand that resolves nowhere is a typo that would otherwise read as a pass.
+   */
+  readonly missing: readonly string[]
+}
+
+export interface ResolveOptions {
+  /**
+   * Whether a name may resolve at the project root when `.claude/` does not
+   * carry it. False for the default list, which names three folders a project
+   * is expected to hold under `.claude/` and nowhere else.
+   */
+  readonly canResolveAtRoot?: boolean
+}
+
+function locate(
+  root: string,
+  name: string,
+  bases: readonly string[],
+): { readonly dir: string; readonly base: string } | undefined {
+  for (const base of bases) {
+    const dir = resolve(root, base, name)
+    if (existsSync(`${dir}/${INDEX_FILE}`)) return { dir, base }
+  }
+
+  return undefined
+}
+
 /**
  * Resolves the folders to audit under `root`.
  *
@@ -77,34 +134,49 @@ async function readEntries(dir: string): Promise<string[]> {
  * folder beneath it, so a domain that outgrew one file and split is audited at
  * the same grain as one that did not. Discovery of the nested folders runs
  * through the shared walker, which is what keeps `.gitignore` and the vendored
- * prune governing this scan as well as index regeneration.
+ * prune governing this scan as well as index regeneration. That prune is what
+ * lets a root folder be walked at all, since a name at the project root sits
+ * beside `node_modules` and a build output.
  *
- * A requested folder that does not exist is dropped rather than reported. The
- * default list names three folders and a project carrying one of them is the
- * ordinary case.
+ * The project root is reached only when the caller opts in, so a target holding
+ * a root `wireframes/` is not audited against a standard it never adopted by
+ * the mere act of running the command. `.claude/` still wins a name carried by
+ * both, and the scope line prints the resolved path so a caller reads which
+ * base was taken rather than inferring it.
+ *
+ * Nothing above this asks where a folder came from. A name that resolves at the
+ * root is measured by every rule that generalizes and gated out of the rules a
+ * single standard carries, which `governsContent` decides from the name.
  */
 export async function resolveFolders(
   root: string,
   names: readonly string[] = DEFAULT_FOLDERS,
-): Promise<AuditedFolder[]> {
+  { canResolveAtRoot = false }: ResolveOptions = {},
+): Promise<FolderResolution> {
+  const bases = canResolveAtRoot ? [CLAUDE_BASE, ROOT_BASE] : [CLAUDE_BASE]
   const folders: AuditedFolder[] = []
+  const missing: string[] = []
 
   for (const name of names) {
-    const dir = resolve(root, '.claude', name)
-    if (!existsSync(`${dir}/${INDEX_FILE}`)) continue
+    const found = locate(root, name, bases)
+    if (!found) {
+      missing.push(name)
+      continue
+    }
 
-    const dirs = [dir, ...(await listIndexes(dir)).map(dirname)]
+    const dirs = [found.dir, ...(await listIndexes(found.dir)).map(dirname)]
 
     for (const each of [...new Set(dirs)].sort()) {
       folders.push({
         name,
+        base: found.base,
         rel: relative(root, each),
         indexPath: `${each}/${INDEX_FILE}`,
         entries: await readEntries(each),
-        nested: each !== dir,
+        nested: each !== found.dir,
       })
     }
   }
 
-  return folders
+  return { folders, missing }
 }

package/src/sandbox/census.ts

@@ -70,7 +70,7 @@ export function listSkills(root: string): string[] {
  * Maps a scenario to the skill it drives, trying two spellings in order.
  *
  * `<category>-<command>` is the rule `.claude/context/sandbox/coverage.md` states, and it
- * alone pairs 29 of 55 skills. The bare `<command>` fallback is what reaches the
+ * alone pairs 29 of 54 skills. The bare `<command>` fallback is what reaches the
  * rest: `claude/setup-init.sh` drives the `setup-init` skill, not a
  * `claude-setup-init` that does not exist. Stating one spelling and shipping two
  * is what let the audit report a paired skill as unpaired.

package/standards/bundled/snippets.md

@@ -1,7 +1,7 @@
 ---
 title: Snippet reference
 description: Snippet reference and authoring conventions
-consumers: create-standard
+consumers: create-snippet
 ---
 
 # Snippet reference

package/standards/skill.md

@@ -11,7 +11,7 @@ Skills give Claude Code domain-specific constraints and rules inline, so it can
 
 ## Scope
 
-Governs a skill folder under `skills/` as one artifact: `SKILL.md`, its optional sibling `REQUIREMENT.md`, and the bundled reference, script, and asset folders beside them.
+Governs a skill folder under `skills/` as one artifact: `SKILL.md`, its sibling `REQUIREMENT.md`, and the bundled reference, script, and asset folders beside them.
 
 Does not govern:
 
@@ -68,14 +68,14 @@ allowed-tools: <tools required>
 
 ## Structure
 
-- Skill is a folder named in kebab-case containing `SKILL.md` (required), `REQUIREMENT.md` (optional), `scripts/` (optional), `references/` (optional), `assets/` (optional)
+- Skill is a folder named in kebab-case containing `SKILL.md` (required), `REQUIREMENT.md` (required), `scripts/` (optional), `references/` (optional), `assets/` (optional)
 - `SKILL.md` must start with YAML frontmatter between `---` delimiters
 - No `README.md` inside the skill folder
 - No spaces, capitals, or underscores in folder or skill name
 
 ## Requirement
 
-`REQUIREMENT.md` states what a skill is for, so a proposed change can be argued against something. This standard governs shape across the corpus and the requirement governs scope for one skill. Claude Code loads `SKILL.md` as the entry and ignores the sibling, so the file costs a target session nothing.
+`REQUIREMENT.md` states what a skill is for, so a proposed change can be argued against something and the corpus can be read to decide whether a skill should exist at all. This standard governs shape across the corpus and the requirement governs scope and behavior for one skill. Claude Code loads `SKILL.md` as the entry and ignores the sibling, so the file costs a target session nothing.
 
 The file serves a second purpose beside the argument. A skill body is procedural by design, so what the skill is for sits spread across its steps rather than stated in one place. The requirement is the compressed statement a reader gets before opening the body, and that purpose holds whether or not the skill's scope is contested.
 
@@ -83,7 +83,7 @@ Read it before editing the skill. When a change closes no gap the requirement st
 
 Write the gaps from what the skill is for, then compare the body against them. Deriving the requirement from the body is circular, because a requirement reverse-engineered from an overfitted skill records the overfitting as the requirement. That failure costs more under the orientation purpose than under the argument one, since a file summarizing the body misinforms whoever reads it in place of the body rather than merely failing to gate a change.
 
-A skill earns one when a reader cannot recover what the skill is for from the body alone. Apply the test to a skill nobody in the session has read before: read the body once, then state both the failures the skill exists to prevent and the nearest thing it deliberately does not do. A body answering both is its own specification and needs no sibling, and a body leaving either open earns one. Length is a weak proxy for that, since a short skill with a contested boundary earns one and a long skill doing one plain thing may not.
+Every skill carries one. Coverage was selective while the file existed only to disambiguate a contested boundary, and a file present for some skills and absent for others cannot be scanned, because an absence reads as a gap rather than as a verdict. A skill whose scope nobody contests still owes the statement, since the reader deciding whether a skill should exist reads the corpus rather than one entry. A new skill is created with the sibling beside it rather than acquiring one in a later sweep.
 
 ### What a working requirement looks like
 

package/claude/skills/claude-design-propose/SKILL.md

@@ -1,15 +0,0 @@
----
-name: claude-design-propose
-description: Retired. `claude-design-extract` absorbed this skill and now takes the greenfield path itself. Invoke `aitk:claude-design-extract` instead.
-disable-model-invocation: true
----
-
-# Design propose
-
-Retired. `claude-design-extract` absorbed the greenfield path, picks it from what the project has, and its description carries every trigger this skill used to route on.
-
-Invoke `aitk:claude-design-extract` instead. It reads `.claude/REQUIREMENTS.md` for the `## Personality` paragraph and `.claude/ARCHITECTURE.md` for platform signals when the project has no UI code, which is what this skill did.
-
-This body exists so a project that installed the plugin before the merge keeps resolving the old name for one sync cycle. It ships in `0.18.0` and is removed in `0.19.0`.
-
-`scripts/sandbox/claude/design-propose.sh` goes at the same time, but its fixture does not. That scenario is the only greenfield coverage the survivor has, so `0.19.0` folds it into `scripts/sandbox/claude/design-extract.sh` as a second arm rather than deleting it. Removing the file outright drops the greenfield path from the catalog.