@open-agent-toolkit/cli 0.2.59 → 0.2.63

package/dist/commands/init/tools/shared/skill-script-references.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Skill-to-script reference integrity.
+ *
+ * A shipped skill may name a helper script through its installed destination,
+ * `.oat/scripts/<name>`. Nothing in the install path proves the pack that ships
+ * the skill also ships that script, so a rename or a pack move can leave a
+ * skill pointing at a file its own installation never materializes.
+ *
+ * This module supplies the join: a syntax-aware extractor for the reference
+ * spellings authored Markdown actually uses, a manifest-derived view of the
+ * shipped skill surface, and an owning-pack resolver. Callers compare the two
+ * and fail when a shipped skill references a script its owning pack does not
+ * ship.
+ *
+ * The shipped surface is derived from the pack manifest, never from the
+ * canonical `.agents/skills` directory listing: that listing is a superset that
+ * also holds repository-local authoring and utility skills no pack ships. Those
+ * directories are classified and reported, never resolved to a pack and never a
+ * failure by themselves.
+ *
+ * Scan boundary: `extractScriptReferences` takes any text, but the shipping
+ * caller feeds it authored Markdown only — every `**\/*.md` under a skill
+ * directory except the vendored `references/docs/` copies. That covers every
+ * reference in the tree today, since each of the six skill files naming
+ * `.oat/scripts` is a `SKILL.md`. A skill that ships a non-Markdown asset
+ * carrying a script reference would fall outside this scan, so widen the caller
+ * deliberately rather than assuming this module already sees it.
+ */
+import type { PackDefinition, PackName } from '../../../tools/shared/types.js';
+/** Installed destination prefix produced by the manifest's `script()` helper. */
+export declare const SCRIPT_DESTINATION_PREFIX = ".oat/scripts/";
+/** One extracted reference, kept line-addressed so failures cite a location. */
+export interface ScriptReference {
+    /** Manifest-comparable destination, e.g. `.oat/scripts/resolve-tracking.sh`. */
+    reference: string;
+    /** 1-based line number of the occurrence within the scanned text. */
+    line: number;
+}
+/** Authored text belonging to one skill, ready to be scanned. */
+export interface SkillScriptSource {
+    /** Canonical skill name, as shipped by a pack. */
+    skill: string;
+    /** Display path used in failure messages. */
+    file: string;
+    /** File contents. */
+    text: string;
+}
+/** A shipped skill naming a script its owning pack does not ship. */
+export interface ScriptReferenceViolation {
+    skill: string;
+    file: string;
+    line: number;
+    reference: string;
+    /** Every pack that ships the skill; membership in any one satisfies the check. */
+    packs: PackName[];
+    /** Script destinations those packs do ship, for an actionable message. */
+    shipped: string[];
+}
+/** How a canonical `.agents/skills` directory relates to the pack manifest. */
+export type CanonicalSkillDirClass = 'shipped' | 'canonical-unshipped';
+/** Split of canonical skill directories by manifest membership. */
+export interface CanonicalSkillDirClassification {
+    shipped: string[];
+    canonicalUnshipped: string[];
+}
+/**
+ * Extract every `.oat/scripts/<name>` reference from authored text.
+ *
+ * Scanning is line-by-line so each occurrence carries its own line number, and
+ * so a reference can never be assembled across a line break.
+ *
+ * A reference is returned essentially as authored. Nothing is truncated to a
+ * shipped-looking prefix, and the only edits are dropping the Markdown
+ * decoration around it — a closing emphasis run and at most one prose mark — so
+ * a malformed name reaches the manifest comparison intact and fails there
+ * rather than being normalized into a name that happens to exist.
+ */
+export declare function extractScriptReferences(text: string): ScriptReference[];
+/**
+ * The union of every pack's skill assets: the surface the manifest claims to
+ * ship, which is what the contract checks.
+ */
+export declare function listShippedSkills(manifest?: readonly PackDefinition[]): string[];
+/** Script destinations shipped by one pack. */
+export declare function listPackScriptDestinations(pack: PackName, manifest?: readonly PackDefinition[]): string[];
+/**
+ * Classify a canonical skill directory against the manifest.
+ *
+ * `canonical-unshipped` is an ordinary, expected state: repository-local
+ * authoring and utility skills live under `.agents/skills` without belonging to
+ * any pack. It is reported, never failed.
+ */
+export declare function classifyCanonicalSkillDir(name: string, manifest?: readonly PackDefinition[]): CanonicalSkillDirClass;
+/** Classify a whole directory listing in one pass. */
+export declare function classifyCanonicalSkillDirs(names: readonly string[], manifest?: readonly PackDefinition[]): CanonicalSkillDirClassification;
+/**
+ * Shipped skills the manifest names but whose canonical directory is absent.
+ *
+ * The inverse of `classifyCanonicalSkillDirs`, and unlike an unshipped
+ * directory this *is* a failure: the manifest promises to install something the
+ * repository does not contain.
+ */
+export declare function findMissingShippedSkillDirs(existingDirs: readonly string[], manifest?: readonly PackDefinition[]): string[];
+/**
+ * Every pack that ships `skillName`.
+ *
+ * Throws for a name no pack ships. That is a caller bug rather than a repository
+ * defect: callers drive from `listShippedSkills`, so an unshipped canonical
+ * directory never reaches here.
+ *
+ * A skill carried by more than one pack resolves to all of them, and membership
+ * in any one satisfies the reference check — the same shared-ownership rule the
+ * manifest applies to a script shipped by two packs under one `sharedOwner`.
+ */
+export declare function resolveOwningPack(skillName: string, manifest?: readonly PackDefinition[]): PackName[];
+/**
+ * The contract itself: every script reference authored by a shipped skill must
+ * name a `kind: 'script'` destination of a pack that ships that skill.
+ *
+ * Sources for skills no pack ships must not be passed; drive callers from
+ * `listShippedSkills` so `resolveOwningPack` stays a caller-bug signal.
+ */
+export declare function findUnshippedScriptReferences(sources: readonly SkillScriptSource[], manifest?: readonly PackDefinition[]): ScriptReferenceViolation[];
+/** Render one violation so the failure names the skill, reference, and pack. */
+export declare function formatScriptReferenceViolation({ skill, file, line, reference, packs, shipped, }: ScriptReferenceViolation): string;
+//# sourceMappingURL=skill-script-references.d.ts.map

package/dist/commands/init/tools/shared/skill-script-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-script-references.d.ts","sourceRoot":"","sources":["../../../../../src/commands/init/tools/shared/skill-script-references.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAEV,cAAc,EACd,QAAQ,EACT,MAAM,8BAA8B,CAAC;AAEtC,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,kBAAkB,CAAC;AAiKzD,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC9B,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,iEAAiE;AACjE,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qEAAqE;AACrE,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,+EAA+E;AAC/E,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,qBAAqB,CAAC;AAEvE,mEAAmE;AACnE,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE,CA4BvE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,MAAM,EAAE,CAUV;AAED,+CAA+C;AAC/C,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,MAAM,EAAE,CAQV;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,sBAAsB,CAIxB;AAED,sDAAsD;AACtD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,+BAA+B,CAOjC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,MAAM,EAAE,CAGV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,QAAQ,EAAE,CAgBZ;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,QAAQ,GAAE,SAAS,cAAc,EAAkB,GAClD,wBAAwB,EAAE,CAkB5B;AAED,gFAAgF;AAChF,wBAAgB,8BAA8B,CAAC,EAC7C,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,OAAO,GACR,EAAE,wBAAwB,GAAG,MAAM,CAInC"}

package/dist/commands/init/tools/shared/skill-script-references.js

@@ -0,0 +1,311 @@
+/**
+ * Skill-to-script reference integrity.
+ *
+ * A shipped skill may name a helper script through its installed destination,
+ * `.oat/scripts/<name>`. Nothing in the install path proves the pack that ships
+ * the skill also ships that script, so a rename or a pack move can leave a
+ * skill pointing at a file its own installation never materializes.
+ *
+ * This module supplies the join: a syntax-aware extractor for the reference
+ * spellings authored Markdown actually uses, a manifest-derived view of the
+ * shipped skill surface, and an owning-pack resolver. Callers compare the two
+ * and fail when a shipped skill references a script its owning pack does not
+ * ship.
+ *
+ * The shipped surface is derived from the pack manifest, never from the
+ * canonical `.agents/skills` directory listing: that listing is a superset that
+ * also holds repository-local authoring and utility skills no pack ships. Those
+ * directories are classified and reported, never resolved to a pack and never a
+ * failure by themselves.
+ *
+ * Scan boundary: `extractScriptReferences` takes any text, but the shipping
+ * caller feeds it authored Markdown only — every `**\/*.md` under a skill
+ * directory except the vendored `references/docs/` copies. That covers every
+ * reference in the tree today, since each of the six skill files naming
+ * `.oat/scripts` is a `SKILL.md`. A skill that ships a non-Markdown asset
+ * carrying a script reference would fall outside this scan, so widen the caller
+ * deliberately rather than assuming this module already sees it.
+ */
+import { PACK_MANIFEST } from '../../../tools/shared/pack-manifest.js';
+/** Installed destination prefix produced by the manifest's `script()` helper. */
+export const SCRIPT_DESTINATION_PREFIX = '.oat/scripts/';
+// Extraction runs in two stages, and the split is the whole point.
+//
+// Stage one finds where a reference starts. The lookbehind rejects a candidate
+// glued to an identifier, so `myrepo.oat/scripts/…` never matches, while every
+// rooted spelling authored today still does: a leading `/` is explicitly
+// allowed, which covers `$SCOPE_ROOT/.oat/scripts/…`, `${HOME}/.oat/scripts/…`,
+// `~/.oat/scripts/…`, and the plain relative form. The trailing slash is
+// required, so a mention of the directory itself — `${HOME}/.oat/scripts` — is
+// not a reference start at all.
+//
+// `_` is absent from the lookbehind on purpose, so an italic `_.oat/scripts/…_`
+// still starts a match. The glued-identifier case it used to cover —
+// `myrepo_.oat/scripts/…` — is rejected instead by `readOpeningEmphasis`, which
+// can tell an emphasis delimiter at a word boundary from an underscore inside a
+// name. A lookbehind cannot make that distinction, and a wrongly rejected start
+// is a silent miss.
+const SCRIPT_REFERENCE_START = /(?<![A-Za-z0-9.-])\.oat\/scripts\//g;
+// Characters that may not sit next to an emphasis delimiter for it to read as
+// emphasis rather than as part of an identifier.
+const IDENTIFIER_CHARACTER = /[\p{L}\p{N}._-]/u;
+// Stage two reads the name that follows, losslessly, up to the first character
+// that closes the surrounding Markdown construct: whitespace, the backtick or
+// quote closing an inline span, the `)` or `>` closing a link target, or a
+// list/table separator.
+//
+// Reading the whole token rather than matching a "valid-looking" name is what
+// makes the check fail closed. A name class that stopped at the first
+// unexpected character would quietly truncate `…/resolve-tracking.sh/<file>`
+// down to the shipped `resolve-tracking.sh` and report success, and a class
+// that required a leading alphanumeric would drop `_missing.sh` on the floor
+// instead of flagging it. Both are fail-open, and a fail-open integrity check
+// is worse than none.
+//
+// Only true closers belong here, never ordinary punctuation. Every character in
+// this set truncates the token, so admitting one that can appear mid-path would
+// reintroduce exactly the truncation this design removes.
+const REFERENCE_TOKEN_TERMINATOR = /[\s`"'),;\]|>]/;
+// Prose puts a mark after a path without making it part of the path, and each
+// of these is a real authored spelling: `run .oat/scripts/x.sh.`,
+// `did you run .oat/scripts/x.sh?`, `run .oat/scripts/x.sh: it resolves…`.
+//
+// Exactly one such character is dropped, and only in the final position. That
+// is deliberately weaker than trimming a run: a doubled `x.sh..` keeps a period
+// and still fails, so a malformed spelling cannot be normalized into a shipped
+// name. Position-anchored trimming also cannot truncate a path the way a
+// terminator does.
+const TRAILING_PROSE_MARK = /[.:!?]$/;
+// A token carrying shell, glob, or documentation-placeholder syntax names no
+// concrete file: `~/.oat/scripts/<file>` and `.oat/scripts/${NAME}` are prose
+// about the directory, not references into it. These negatives are as
+// load-bearing as the matches, since a false positive here blocks CI on
+// documentation that is entirely correct.
+//
+// This test runs after every trailing decoration is dropped, so a `?` that
+// merely ended a question, or a `*` that merely closed an emphasis span, is
+// gone before it can be mistaken for a glob.
+const PLACEHOLDER_SYNTAX = /[<{}$*?]/;
+function readReferenceToken(line, from) {
+    let end = from;
+    while (end < line.length && !REFERENCE_TOKEN_TERMINATOR.test(line[end])) {
+        end += 1;
+    }
+    return line.slice(from, end);
+}
+/**
+ * The emphasis run opening this reference, or `null` when the run is glued to a
+ * name and therefore opened nothing.
+ *
+ * The opening run is the only reliable evidence that a trailing delimiter is
+ * emphasis rather than content, and both delimiters need that evidence:
+ *
+ * - `_` is a legal filename character, so `.oat/scripts/x.sh_` with no opening
+ *   run keeps its underscore. That is what makes a typo such as
+ *   `resolve-tracking.sh_` still fail instead of being normalized into the
+ *   shipped name.
+ * - `*` is not a legal filename character, but it *is* glob syntax, which this
+ *   module treats as prose about the directory. An unpaired
+ *   `.oat/scripts/resolve-tracking.sh*` is a glob, and stripping its star would
+ *   normalize it into a shipped name — the exact fail-open this design exists to
+ *   prevent. Leaving it attached keeps it a glob, which is skipped.
+ *
+ * `null` rejects the match outright for `myrepo_.oat/scripts/x.sh`, where the
+ * underscore is glued to an identifier. The identifier test is Unicode-aware so
+ * `café_.oat/scripts/x.sh` is rejected too.
+ */
+function readOpeningEmphasis(line, at) {
+    let start = at;
+    while (start > 0 && (line[start - 1] === '_' || line[start - 1] === '*')) {
+        start -= 1;
+    }
+    const run = line.slice(start, at);
+    if (run.length === 0)
+        return { asterisks: 0, underscores: 0 };
+    const preceding = start > 0 ? line[start - 1] : '';
+    if (IDENTIFIER_CHARACTER.test(preceding))
+        return null;
+    return {
+        asterisks: run.split('').filter((char) => char === '*').length,
+        underscores: run.split('').filter((char) => char === '_').length,
+    };
+}
+/**
+ * Drop the decoration Markdown and prose leave on the end of a reference.
+ *
+ * Each delimiter comes off only up to the length of its opening run, so an
+ * unpaired trailing `*` or `_` survives as part of the name and is judged on its
+ * merits downstream. At most one prose mark is dropped in total, so a doubled
+ * `x.sh..` keeps a period and still fails the manifest comparison.
+ *
+ * A single ordered pass is not enough, because the layers interleave:
+ * `**x.sh**.` closes its emphasis outside the sentence period, and `_*x.sh*_`
+ * nests two delimiters. The loop peels whichever layer is currently outermost
+ * until no budget is left.
+ */
+function stripTrailingDecoration(token, opening) {
+    let name = token;
+    let asterisks = opening.asterisks;
+    let underscores = opening.underscores;
+    let proseMarkDropped = false;
+    for (;;) {
+        if (asterisks > 0 && name.endsWith('*')) {
+            name = name.slice(0, -1);
+            asterisks -= 1;
+            continue;
+        }
+        if (underscores > 0 && name.endsWith('_')) {
+            name = name.slice(0, -1);
+            underscores -= 1;
+            continue;
+        }
+        if (!proseMarkDropped && TRAILING_PROSE_MARK.test(name)) {
+            name = name.replace(TRAILING_PROSE_MARK, '');
+            proseMarkDropped = true;
+            continue;
+        }
+        break;
+    }
+    return name;
+}
+function skillNameOf(asset) {
+    return asset.id.slice('skill:'.length);
+}
+/**
+ * Extract every `.oat/scripts/<name>` reference from authored text.
+ *
+ * Scanning is line-by-line so each occurrence carries its own line number, and
+ * so a reference can never be assembled across a line break.
+ *
+ * A reference is returned essentially as authored. Nothing is truncated to a
+ * shipped-looking prefix, and the only edits are dropping the Markdown
+ * decoration around it — a closing emphasis run and at most one prose mark — so
+ * a malformed name reaches the manifest comparison intact and fails there
+ * rather than being normalized into a name that happens to exist.
+ */
+export function extractScriptReferences(text) {
+    const references = [];
+    for (const [index, line] of text.split(/\r?\n/).entries()) {
+        for (const match of line.matchAll(SCRIPT_REFERENCE_START)) {
+            const opening = readOpeningEmphasis(line, match.index);
+            // A delimiter glued to a name, so it never opened emphasis.
+            if (opening === null)
+                continue;
+            const name = stripTrailingDecoration(readReferenceToken(line, match.index + match[0].length), opening);
+            // Prose about the directory, not a reference into it.
+            if (PLACEHOLDER_SYNTAX.test(name))
+                continue;
+            // A bare `.oat/scripts/` mention names no script.
+            if (name.length === 0)
+                continue;
+            references.push({
+                reference: `${SCRIPT_DESTINATION_PREFIX}${name}`,
+                line: index + 1,
+            });
+        }
+    }
+    return references;
+}
+/**
+ * The union of every pack's skill assets: the surface the manifest claims to
+ * ship, which is what the contract checks.
+ */
+export function listShippedSkills(manifest = PACK_MANIFEST) {
+    const names = new Set();
+    for (const pack of manifest) {
+        for (const asset of pack.assets) {
+            if (asset.kind === 'skill')
+                names.add(skillNameOf(asset));
+        }
+    }
+    return [...names].sort();
+}
+/** Script destinations shipped by one pack. */
+export function listPackScriptDestinations(pack, manifest = PACK_MANIFEST) {
+    const definition = manifest.find(({ name }) => name === pack);
+    if (!definition)
+        throw new Error(`Unknown pack: ${pack}`);
+    return definition.assets
+        .filter((asset) => asset.kind === 'script')
+        .map(({ destination }) => destination)
+        .sort();
+}
+/**
+ * Classify a canonical skill directory against the manifest.
+ *
+ * `canonical-unshipped` is an ordinary, expected state: repository-local
+ * authoring and utility skills live under `.agents/skills` without belonging to
+ * any pack. It is reported, never failed.
+ */
+export function classifyCanonicalSkillDir(name, manifest = PACK_MANIFEST) {
+    return listShippedSkills(manifest).includes(name)
+        ? 'shipped'
+        : 'canonical-unshipped';
+}
+/** Classify a whole directory listing in one pass. */
+export function classifyCanonicalSkillDirs(names, manifest = PACK_MANIFEST) {
+    const shipped = new Set(listShippedSkills(manifest));
+    return {
+        shipped: names.filter((name) => shipped.has(name)).sort(),
+        canonicalUnshipped: names.filter((name) => !shipped.has(name)).sort(),
+    };
+}
+/**
+ * Shipped skills the manifest names but whose canonical directory is absent.
+ *
+ * The inverse of `classifyCanonicalSkillDirs`, and unlike an unshipped
+ * directory this *is* a failure: the manifest promises to install something the
+ * repository does not contain.
+ */
+export function findMissingShippedSkillDirs(existingDirs, manifest = PACK_MANIFEST) {
+    const existing = new Set(existingDirs);
+    return listShippedSkills(manifest).filter((name) => !existing.has(name));
+}
+/**
+ * Every pack that ships `skillName`.
+ *
+ * Throws for a name no pack ships. That is a caller bug rather than a repository
+ * defect: callers drive from `listShippedSkills`, so an unshipped canonical
+ * directory never reaches here.
+ *
+ * A skill carried by more than one pack resolves to all of them, and membership
+ * in any one satisfies the reference check — the same shared-ownership rule the
+ * manifest applies to a script shipped by two packs under one `sharedOwner`.
+ */
+export function resolveOwningPack(skillName, manifest = PACK_MANIFEST) {
+    const packs = manifest
+        .filter((pack) => pack.assets.some((asset) => asset.kind === 'skill' && skillNameOf(asset) === skillName))
+        .map(({ name }) => name);
+    if (packs.length === 0) {
+        throw new Error(`resolveOwningPack: skill "${skillName}" is shipped by no pack; pass a name from listShippedSkills()`);
+    }
+    return packs;
+}
+/**
+ * The contract itself: every script reference authored by a shipped skill must
+ * name a `kind: 'script'` destination of a pack that ships that skill.
+ *
+ * Sources for skills no pack ships must not be passed; drive callers from
+ * `listShippedSkills` so `resolveOwningPack` stays a caller-bug signal.
+ */
+export function findUnshippedScriptReferences(sources, manifest = PACK_MANIFEST) {
+    const violations = [];
+    for (const { skill, file, text } of sources) {
+        const packs = resolveOwningPack(skill, manifest);
+        const shipped = [
+            ...new Set(packs.flatMap((pack) => listPackScriptDestinations(pack, manifest))),
+        ].sort();
+        for (const { reference, line } of extractScriptReferences(text)) {
+            if (shipped.includes(reference))
+                continue;
+            violations.push({ skill, file, line, reference, packs, shipped });
+        }
+    }
+    return violations;
+}
+/** Render one violation so the failure names the skill, reference, and pack. */
+export function formatScriptReferenceViolation({ skill, file, line, reference, packs, shipped, }) {
+    const owner = `pack${packs.length > 1 ? 's' : ''} ${packs.join(', ')}`;
+    const available = shipped.length > 0 ? shipped.join(', ') : 'no scripts';
+    return `${skill} (${owner}) references ${reference} at ${file}:${line}, but ${owner} ${packs.length > 1 ? 'ship' : 'ships'} ${available}`;
+}

package/dist/commands/instructions/instructions.types.d.ts

@@ -35,10 +35,67 @@ export interface InstructionsJsonPayload {
     summary: InstructionsSummary;
     entries: InstructionEntry[];
     actions: InstructionActionRecord[];
+    /**
+     * The normalized repo-relative exclusions this scan was *configured* with, in
+     * resolution order. An entry here is a statement of intent, not a guarantee:
+     * it may name a directory that does not exist, differ in case from the real
+     * path on a case-insensitive filesystem, or be shadowed by the `.oat/repo`
+     * carve-in.
+     *
+     * Read `effectiveExcludedPaths` to learn what was actually protected.
+     *
+     * Additive and omitted entirely when nothing was configured, so payloads from
+     * repositories without a documentation root are byte-identical to the
+     * pre-exclusion shape.
+     */
+    excludedPaths?: string[];
+    /**
+     * The subset of `excludedPaths` that names a real, case-exact directory the
+     * scan can actually prune. This is the field a consumer should trust when
+     * deciding whether a tree is protected; every configured entry missing from
+     * it was also reported as a warning on stderr.
+     *
+     * Present whenever `excludedPaths` is, including as an empty array when every
+     * configured entry turned out to be inert; omitted only when nothing was
+     * configured at all.
+     */
+    effectiveExcludedPaths?: string[];
+    /**
+     * One message per configured exclusion that will not protect anything, the
+     * same text written to stderr in human mode.
+     *
+     * This field is why the JSON surface is complete. `logger.warn` is suppressed
+     * under `--json`, and an entry rejected during normalization (an absolute
+     * path, or one escaping the repository) never reaches `excludedPaths` either
+     * — so without this a `--json` consumer would see no trace at all of an
+     * exclusion that silently does nothing. Omitted when empty.
+     */
+    exclusionWarnings?: string[];
+}
+/**
+ * The resolved exclusion set, split so that intent and effect cannot be
+ * confused. A configured entry that protects nothing is the failure mode this
+ * split exists to surface: silently reporting it as applied would let an
+ * operator believe a documentation tree is safe while pointers are written
+ * into it.
+ */
+export interface InstructionPointerExclusions {
+    /** Normalized entries exactly as configured, in resolution order. */
+    configured: string[];
+    /** The subset that names a real, case-exact, prunable directory. */
+    effective: string[];
+    /** One human-readable warning per configured entry that will do nothing. */
+    warnings: string[];
 }
 export interface InstructionsScanOptions {
     strategy?: InstructionSyncStrategy;
     debug?: (message: string) => void;
+    /**
+     * Repo-root-relative directories whose subtrees are left out of the scan.
+     * Applied after the excluded-root carve-in, so excluding a directory can
+     * never strand a subtree the carve-in re-entered (`.oat/repo/**`).
+     */
+    excludedPaths?: string[];
 }
 export interface InstructionsScanDependencies {
     readdir: (path: string, options: {
@@ -53,6 +110,12 @@ export interface InstructionsScanDependencies {
 export interface InstructionsValidateCommandDependencies {
     buildCommandContext: (options: GlobalOptions) => CommandContext;
     resolveProjectRoot: (cwd: string) => Promise<string>;
+    /**
+     * The single exclusion path both commands resolve through. Sync inherits it
+     * from this interface rather than resolving its own, so validate can never
+     * report drift that sync would refuse to fix.
+     */
+    resolveInstructionPointerExcludes: (repoRoot: string) => Promise<InstructionPointerExclusions>;
     scanInstructionFiles: (repoRoot: string, options?: InstructionsScanOptions, overrides?: Partial<InstructionsScanDependencies>) => Promise<InstructionEntry[]>;
 }
 export interface InstructionsSyncCommandDependencies extends InstructionsValidateCommandDependencies {

package/dist/commands/instructions/instructions.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instructions.types.d.ts","sourceRoot":"","sources":["../../../src/commands/instructions/instructions.types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"instructions.types.d.ts","sourceRoot":"","sources":["../../../src/commands/instructions/instructions.types.ts"],"names":[],"mappings":"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"}

package/dist/commands/instructions/instructions.utils.d.ts

@@ -1,15 +1,64 @@
-import type { InstructionSyncStrategy, InstructionActionRecord, InstructionEntry, InstructionsJsonPayload, InstructionsMode, InstructionsScanOptions, InstructionsScanDependencies, InstructionsSummary } from './instructions.types.js';
+import type { InstructionSyncStrategy, InstructionActionRecord, InstructionEntry, InstructionsJsonPayload, InstructionsMode, InstructionPointerExclusions, InstructionsScanOptions, InstructionsScanDependencies, InstructionsSummary } from './instructions.types.js';
 export declare const EXPECTED_CLAUDE_CONTENT = "@AGENTS.md\n";
 export declare const DEFAULT_INSTRUCTION_SYNC_STRATEGY: InstructionSyncStrategy;
 interface BuildInstructionsPayloadArgs {
     mode: InstructionsMode;
     entries: InstructionEntry[];
     actions: InstructionActionRecord[];
+    excludedPaths?: string[];
+    effectiveExcludedPaths?: string[];
+    exclusionWarnings?: string[];
 }
 export declare function resolveInstructionSyncStrategy(strategy?: InstructionSyncStrategy): InstructionSyncStrategy;
+/**
+ * Canonicalize repo-relative exclusion entries into the exact form the scan
+ * compares against: POSIX separators, collapsed `.` and `..` segments and
+ * duplicate slashes, no trailing slash, de-duplicated, order-preserving.
+ *
+ * Full normalization is what makes the comparison trustworthy. The scan tests
+ * an exclusion against `relative(repoRoot, entryPath)`, which is always
+ * already-normalized, so an un-normalized entry like `apps/./docs` or
+ * `apps//docs` would silently never match and quietly fail open.
+ *
+ * Two classes of entry are dropped rather than normalized:
+ *
+ * - anything resolving to the repository root (`.`, `` , `./`), because
+ *   excluding the root would silence the entire scan — including the
+ *   `.oat/repo` carve-in — from one stray config value; and
+ * - absolute paths and entries escaping the repository (`..`, `../x`), which
+ *   can never name a directory inside the tree being scanned. Dropping them
+ *   keeps a malformed value from masquerading as a matchable exclusion.
+ */
+export declare function normalizeExcludedPaths(excludedPaths?: readonly string[]): string[];
+/**
+ * The directories `oat instructions sync` and `oat instructions validate` skip:
+ * the derived documentation content root first, then the explicit
+ * `documentation.instructionPointerExcludes` opt-outs.
+ *
+ * Both commands resolve exclusions through this one function. That is the
+ * property that matters: if they computed exclusions separately, validate
+ * could report drift in a directory sync refuses to touch, and the repository
+ * would have no clean state to reach.
+ *
+ * Every configured entry is classified rather than trusted. An entry that is
+ * dropped during normalization, names an unexcludable carve-in root, or does
+ * not resolve to a real case-exact directory is reported as a warning and kept
+ * out of `effective`, so no caller can mistake a typo for protection.
+ *
+ * `effective` answers "is this tree protected from pointer writes?", not "did
+ * the exclusion predicate fire for it". An entry that names an already-skipped
+ * built-in root (`.git`, `node_modules`) or sits beneath another exclusion is
+ * still effective, because the operator's intent holds; warning about those
+ * would be a false alarm about exclusions that do work.
+ *
+ * Nothing here deletes or rewrites an existing pointer. Excluding a directory
+ * only stops it being reported and written; a `CLAUDE.md` already inside an
+ * excluded tree is left exactly as it is.
+ */
+export declare function resolveInstructionPointerExcludes(repoRoot: string, overrides?: Partial<InstructionsScanDependencies>): Promise<InstructionPointerExclusions>;
 export declare function scanInstructionFiles(repoRoot: string, options?: InstructionsScanOptions, overrides?: Partial<InstructionsScanDependencies>): Promise<InstructionEntry[]>;
 export declare function buildInstructionsSummary(entries: InstructionEntry[], actions: InstructionActionRecord[]): InstructionsSummary;
-export declare function buildInstructionsPayload({ mode, entries, actions, }: BuildInstructionsPayloadArgs): InstructionsJsonPayload;
+export declare function buildInstructionsPayload({ mode, entries, actions, excludedPaths, effectiveExcludedPaths, exclusionWarnings, }: BuildInstructionsPayloadArgs): InstructionsJsonPayload;
 export declare function formatInstructionsReport(payload: InstructionsJsonPayload, repoRoot?: string): string;
 export {};
 //# sourceMappingURL=instructions.utils.d.ts.map

package/dist/commands/instructions/instructions.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instructions.utils.d.ts","sourceRoot":"","sources":["../../../src/commands/instructions/instructions.utils.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,EACvB,4BAA4B,EAE5B,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,eAAO,MAAM,iCAAiC,EAAE,uBACrC,CAAC;AAcZ,UAAU,4BAA4B;IACpC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,OAAO,EAAE,uBAAuB,EAAE,CAAC;CACpC;AAiCD,wBAAgB,8BAA8B,CAC5C,QAAQ,CAAC,EAAE,uBAAuB,GACjC,uBAAuB,CAEzB;AA2LD,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,uBAA4B,EACrC,SAAS,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACpD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAiO7B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,OAAO,EAAE,uBAAuB,EAAE,GACjC,mBAAmB,CAoBrB;AAgBD,wBAAgB,wBAAwB,CAAC,EACvC,IAAI,EACJ,OAAO,EACP,OAAO,GACR,EAAE,4BAA4B,GAAG,uBAAuB,CAWxD;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,uBAAuB,EAChC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAmCR"}
+{"version":3,"file":"instructions.utils.d.ts","sourceRoot":"","sources":["../../../src/commands/instructions/instructions.utils.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,4BAA4B,EAC5B,uBAAuB,EACvB,4BAA4B,EAE5B,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AACtD,eAAO,MAAM,iCAAiC,EAAE,uBACrC,CAAC;AAcZ,UAAU,4BAA4B;IACpC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACnC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAiCD,wBAAgB,8BAA8B,CAC5C,QAAQ,CAAC,EAAE,uBAAuB,GACjC,uBAAuB,CAEzB;AA2ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,GAAE,SAAS,MAAM,EAAO,GACpC,MAAM,EAAE,CAyBV;AAsDD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACpD,OAAO,CAAC,4BAA4B,CAAC,CAuEvC;AAgID,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,uBAA4B,EACrC,SAAS,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACpD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAkO7B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,OAAO,EAAE,uBAAuB,EAAE,GACjC,mBAAmB,CAoBrB;AAgBD,wBAAgB,wBAAwB,CAAC,EACvC,IAAI,EACJ,OAAO,EACP,OAAO,EACP,aAAa,EACb,sBAAsB,EACtB,iBAAiB,GAClB,EAAE,4BAA4B,GAAG,uBAAuB,CAgCxD;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,uBAAuB,EAChC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAmCR"}