@vibe-agent-toolkit/agent-skills 0.2.0-rc.10 → 0.2.0-rc.12

package/dist/evidence/derive-observations.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-observations.js","sourceRoot":"","sources":["../../src/evidence/derive-observations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"derive-observations.js","sourceRoot":"","sources":["../../src/evidence/derive-observations.ts"],"names":[],"mappings":"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"}

package/dist/evidence/types.d.ts

@@ -40,8 +40,8 @@ export interface PatternDefinition {
 export interface Observation {
     /** Validation code (e.g. 'CAPABILITY_LOCAL_SHELL'). */
     code: string;
-    /** Human-readable claim. */
-    summary: string;
+    /** Human-readable claim, one sentence. Never `summary`: that name always means severity counts. */
+    description: string;
     /** Payload specific to the observation code. */
     payload?: Record<string, unknown>;
     /** patternId[] of evidence records that support this observation. */

package/dist/evidence/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/evidence/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,IAAI,CAAC;AAE3C,mDAAmD;AACnD,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,cAAc,CAAC;IACvB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,kBAAkB,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,qEAAqE;IACrE,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/evidence/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,IAAI,CAAC;AAE3C,mDAAmD;AACnD,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,cAAc,CAAC;IACvB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,kBAAkB,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,mGAAmG;IACnG,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,qEAAqE;IACrE,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B"}

package/dist/files-config.d.ts

@@ -53,7 +53,7 @@ export interface AppliedFilesConfig {
      *
      * Returned rather than written to a `warn` sink because a file vanishing from
      * a bundle is a build FINDING, not a log line: it has to reach the structured
-     * report (`issueCounts`), or a CI consumer reads `warnings: 0` for a build
+     * report's counts (`summary`), or a CI consumer reads `warnings: 0` for a build
      * that silently shipped less than the config asked for.
      */
     dropped: DroppedGlobMatch[];
@@ -184,8 +184,15 @@ export interface ApplyFilesConfigOptions {
  * missing dest. Intended to be called after a copy operation to assert the
  * copy was faithful. Exported so it can be tested directly without running a
  * full applyFilesConfig round-trip.
+ *
+ * The check reads BOTH trees, so each read is guarded as the side it touches: a
+ * source the OS will not read is the skill's refusal, a dest it will not stat or
+ * read is the output's. One guard over the whole pair coded a dest-side errno as
+ * the skill's, with a remedy pointing at the source.
+ *
+ * @param subject - The `files:` entry, phrased for the refusal's message
  */
-export declare function verifyFilesIntegrity(pairs: {
+export declare function verifyFilesIntegrity(subject: string, pairs: {
     absSource: string;
     absDest: string;
 }[]): void;

package/dist/files-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"files-config.d.ts","sourceRoot":"","sources":["../src/files-config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"files-config.d.ts","sourceRoot":"","sources":["../src/files-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AA6BlE,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AA6JpE,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB;;;;;;;OAOG;IACH,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B;;;;;;;;OAQG;IACH,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,YAAY,EAAE,MAAM,GACnB,eAAe,EAAE,CAEnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,YAAY,EAAE,MAAM,GACnB,eAAe,EAAE,CAEnB;AAkDD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAcpB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EAAE,GAAG,SAAS,EACtC,QAAQ,EAAE,cAAc,EAAE,GAAG,SAAS,GACrC,cAAc,EAAE,CA6ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,EAAE,CAEnF;AAED,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,uCAAuC;IACvC,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,GAC9C,IAAI,CAUN;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAyBf;AA6QD,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IAClC,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,iFAAiF;IACjF,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,8EAA8E;IAC9E,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC;;;;;;;;;;OAUG;IACH,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,2BAA2B,CAC/C,WAAW,EAAE,SAAS,cAAc,EAAE,EACtC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,oBAAoB,CAAC,CA8D/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,oBAAoB,EAC9B,YAAY,EAAE,MAAM,GACnB,eAAe,EAAE,CA2BnB;AAmOD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,uBAAuB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmCjG"}

package/dist/files-config.js

@@ -7,13 +7,12 @@
  * - Computing deferred paths for validation
  * - Copying declared build artifacts into a skill output dir (every build path)
  */
-import { statSync } from 'node:fs';
-import { copyFile, lstat, mkdir, stat } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { fileContentHash, globMagicRemainder, hasParentTraversalSegment, isFilesystemAccessError, isGlob, issueLocation, safePath, staticGlobBase, toForwardSlash, toForwardSlashAnyPlatform, } from '@vibe-agent-toolkit/utils';
+import { lstat } from 'node:fs/promises';
+import { classifyFsFault, fileContentHash, followedKind, followedStatSync, fsFaultOf, globMagicRemainder, hasParentTraversalSegment, isGlob, isLinkChainRefusedError, forEachInOrder, issueLocation, mapWithConcurrency, safePath, staticGlobBase, toForwardSlash, toForwardSlashAnyPlatform, withFsFault, withFsFaultSync, } from '@vibe-agent-toolkit/utils';
 import { glob } from 'glob';
 import picomatch from 'picomatch';
-import { withFsAttribution } from './fs-attribution.js';
+import { copyIntoBundle } from './bundle-copy.js';
+import { packagingInputError } from './packaging-errors.js';
 import { materializeIssue } from './validators/rule-engine/index.js';
 import { isNeverPackagedBasename } from './validators/validation-rules.js';
 /**
@@ -75,10 +74,10 @@ async function partitionRegularFiles(matches, absoluteBase) {
     // caller's sorted order regardless of completion order — `droppedRel` and
     // `nonRegularRel` are rendered into error messages an adopter reads, and a set
     // that reshuffles between runs is a diff for no reason.
-    const copyable = await mapWithConcurrency(matches, STAT_CONCURRENCY, (rel) => 
+    const copyable = await mapWithConcurrency(matches, (rel) => 
     // joinUnderRoot asserts the match stays under absoluteBase, the same guard the
     // copy loop applies before reading it.
-    isCopyableFile(safePath.joinUnderRoot(absoluteBase, rel)));
+    isCopyableFile(safePath.joinUnderRoot(absoluteBase, rel), absoluteBase));
     const regular = [];
     const nonRegular = [];
     for (const [i, rel] of matches.entries()) {
@@ -86,25 +85,6 @@ async function partitionRegularFiles(matches, absoluteBase) {
     }
     return { regular, nonRegular };
 }
-/**
- * Enough parallelism to hide per-call latency, low enough to stay far from the
- * default file-descriptor ceiling even with several skills building at once.
- */
-const STAT_CONCURRENCY = 16;
-/** `Promise.all`-shaped, but with at most `limit` calls in flight. Order preserved. */
-async function mapWithConcurrency(items, limit, fn) {
-    const results = Array.from({ length: items.length });
-    let next = 0;
-    const worker = async () => {
-        while (next < items.length) {
-            const i = next++;
-            // Non-null: `i` is always a valid index, guarded by the loop condition.
-            results[i] = await fn(items[i]);
-        }
-    };
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
-    return results;
-}
 /**
  * Whether `copyFile` can read this path as a stream of bytes.
  *
@@ -114,17 +94,25 @@ async function mapWithConcurrency(items, limit, fn) {
  * would move. A dangling link, or one resolving to a directory, throws from `stat`
  * and is reported as not copyable rather than escaping as the build's whole
  * explanation.
+ *
+ * The link is followed only once its chain is read beneath `within` (the glob's
+ * base, in the operator's project): a chain VAT will not hand the kernel — a link
+ * to a network or device path — is a refusal on the source side, thrown, never a
+ * quiet "not copyable".
  */
-async function isCopyableFile(absPath) {
+async function isCopyableFile(absPath, within) {
     try {
         const linkStat = await lstat(absPath);
         if (linkStat.isFile())
             return true;
         if (!linkStat.isSymbolicLink())
             return false;
-        return (await stat(absPath)).isFile();
+        return (await followedKind(absPath, within)) === 'file';
     }
     catch (error) {
+        if (isLinkChainRefusedError(error)) {
+            throw classifyFsFault(error, { side: 'source', origin: 'content', action: `examine ${absPath}` });
+        }
         // Unreadable or dangling. Not copyable is the honest answer, and the caller
         // reports it as a named finding — which is strictly more than the raw errno
         // this replaces ever gave.
@@ -132,9 +120,14 @@ async function isCopyableFile(absPath) {
         // Narrowed to filesystem errors on purpose: a bare `catch {}` here would
         // answer "not a regular file" to a bug in our own code, silently converting a
         // defect into a routine skip. Same predicate the audit walk uses, from one
-        // shared source so the two cannot drift.
-        if (!isFilesystemAccessError(error))
+        // shared source so the two cannot drift. A machine that ran out (`exhausted`,
+        // `busy`) says nothing about the match: thrown, classified, never a skip.
+        const faultClass = fsFaultOf(error)?.faultClass;
+        if (faultClass === undefined)
             throw error;
+        if (faultClass === 'exhausted' || faultClass === 'busy') {
+            throw classifyFsFault(error, { side: 'source', origin: 'content', action: `examine ${absPath}` });
+        }
         return false;
     }
 }
@@ -155,8 +148,16 @@ async function isCopyableFile(absPath) {
  * text is kept verbatim inside it, because it is what distinguishes a permission
  * problem from a full disk from a vanished mount.
  */
-async function attributed(entry, absPath, projectRoot, work, action) {
-    return withFsAttribution(`files: source '${entry.source}' resolved to ${anchoredPath(absPath, projectRoot)}`, work, action);
+function attributed(entry, absPath, projectRoot, work) {
+    return withFsFault({ side: 'source', origin: 'content', action: `read ${entrySubject(entry, absPath, projectRoot)}` }, () => Promise.resolve(work()));
+}
+/** How a failure names a `files:` entry: the `source:` the author wrote, and where it resolved. */
+function entrySubject(entry, absPath, projectRoot) {
+    return `files: source '${entry.source}' resolved to ${anchoredPath(absPath, projectRoot)}`;
+}
+/** Copy one file a `files:` entry names into the bundle, each side's refusal coded as that side's. */
+function copyEntryFile(entry, absSource, bundle, projectRoot) {
+    return copyIntoBundle(entrySubject(entry, absSource, projectRoot), absSource, bundle.root, bundle.dest);
 }
 /**
  * Turn never-package drops into reportable findings.
@@ -217,7 +218,7 @@ function globMatchesToIssues(matches, locationRoot, code) {
  *
  * Load-bearing for every THROWN message in this module, not only for issue
  * locations: `applyFilesConfig`'s throws reach `vat skills build`'s stdout
- * verbatim as `failedSkills[].message`, so an absolute path there publishes the
+ * verbatim as a `SKILL_PACKAGING_FAILED` finding's `message`, so an absolute path there publishes the
  * developer's home directory into whatever issue or CI log the report is pasted
  * into. Build-report messages are project-relative, never absolute.
  */
@@ -311,7 +312,7 @@ export function mergeFilesConfig(defaults, perSkill) {
         for (const entry of perSkill) {
             const normalized = normalizeRelPath(entry.dest);
             if (destSet.has(normalized)) {
-                throw new Error(`Duplicate dest in per-skill files config: '${entry.dest}'. ` +
+                throw packagingInputError(`Duplicate dest in per-skill files config: '${entry.dest}'. ` +
                     `Each dest must be unique within a skill's files configuration.`);
             }
             destSet.add(normalized);
@@ -369,30 +370,38 @@ export function explicitFilesConfigDests(files) {
  * missing dest. Intended to be called after a copy operation to assert the
  * copy was faithful. Exported so it can be tested directly without running a
  * full applyFilesConfig round-trip.
+ *
+ * The check reads BOTH trees, so each read is guarded as the side it touches: a
+ * source the OS will not read is the skill's refusal, a dest it will not stat or
+ * read is the output's. One guard over the whole pair coded a dest-side errno as
+ * the skill's, with a remedy pointing at the source.
+ *
+ * @param subject - The `files:` entry, phrased for the refusal's message
  */
-export function verifyFilesIntegrity(pairs) {
+export function verifyFilesIntegrity(subject, pairs) {
     for (const { absSource, absDest } of pairs) {
-        // `statSync` in a guard rather than `existsSync`, because `existsSync`
-        // answers FALSE for a file that is present but unreadable — so a permissions
-        // problem on the dest was reported as "dest file missing", sending the author
-        // to look for a file that is sitting right there. Only a real ENOENT is
-        // missing; anything else is the filesystem refusing the path, and is rethrown
-        // for the caller to attribute to the `files:` entry.
-        try {
-            statSync(absDest);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-            throw new Error(`files: integrity check failed — dest file missing: ${toForwardSlash(absDest)}`);
-        }
-        const srcHash = fileContentHash(absSource);
-        const dstHash = fileContentHash(absDest);
+        const srcHash = withFsFaultSync({ side: 'source', origin: 'content', action: `read ${subject} for verification` }, () => fileContentHash(absSource));
+        const dstHash = withFsFaultSync({ side: 'destination', shapeFromSource: true, action: `verify ${subject} in the bundle` }, () => destContentHash(absDest));
         if (srcHash !== dstHash) {
             throw new Error(`files: integrity check failed — content mismatch at dest: ${toForwardSlash(absDest)}`);
         }
     }
 }
+/**
+ * The dest's content hash. A followed `stat` in a guard rather than `existsSync`,
+ * because `existsSync` answers FALSE for a file that is present but unreadable —
+ * so a permissions problem on the dest was reported as "dest file missing",
+ * sending the author to look for a file that is sitting right there. Only
+ * resolving to nothing is missing; anything else is the filesystem refusing the
+ * path, and is rethrown for the caller's guard to code.
+ */
+function destContentHash(absDest) {
+    // The dest is the file this build just wrote — VAT's own path, so it is its own tree.
+    if (followedStatSync(absDest, absDest) === undefined) {
+        throw new Error(`files: integrity check failed — dest file missing: ${toForwardSlash(absDest)}`);
+    }
+    return fileContentHash(absDest);
+}
 /**
  * Verify that the on-disk contents of a glob entry's dest subtree EXACTLY match
  * the set of rel paths the copy step intended to write — no missing, no extra.
@@ -449,31 +458,36 @@ export async function verifyDestSet(destDir, expectedRel, source) {
  * Throws on missing source or if source is a directory.
  */
 async function copyNonGlobEntry(entry, absoluteSource, projectRoot, skillOutputDir) {
-    // `statSync` in a guard, not `existsSync`: `existsSync` swallows EACCES and
+    // A followed `stat` in a guard, not `existsSync`: `existsSync` swallows EACCES and
     // answers FALSE, so a source the process merely cannot REACH — one under a
     // directory it lacks permission to traverse — was reported as "does not exist".
     // For a `dist/` source that also appended `buildArtifactHint`, telling the
     // author to run a build that would not have helped: a confidently wrong
-    // diagnosis plus a confidently wrong remedy. Only ENOENT is absence; anything
-    // else is the filesystem refusing the path, and `attributed` at the call site
-    // names the entry.
-    let sourceStat;
-    try {
-        sourceStat = statSync(absoluteSource);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-        throw new Error(`files: source '${entry.source}' does not exist (resolved to ${anchoredPath(absoluteSource, projectRoot)}).${buildArtifactHint(entry.source)}`);
-    }
-    if (sourceStat.isDirectory()) {
-        throw new Error(`files: source '${entry.source}' is a directory; use a glob like '${entry.source}/**/*' to copy its contents.`);
-    }
+    // diagnosis plus a confidently wrong remedy. Only resolving to nothing is absence; anything
+    // else is the filesystem refusing the path, and `attributed` names the entry.
+    //
+    // The source's `stat` is guarded as well as its copy. Guarding the copy alone
+    // left a source under a directory the process cannot traverse escaping as a bare
+    // errno — and an EXPLICIT entry is the spelling that unambiguously says "ship
+    // this file", so the build owes its author an error that names it back. (The two
+    // deliberate errors below carry no errno, so `attributed` passes them through.)
+    //
+    // The source is crawled beneath the project root: its link chain is read by its
+    // text before the kernel follows it, and a chain VAT will not hand the kernel is
+    // a refusal `attributed` names, never "does not exist".
+    await attributed(entry, absoluteSource, projectRoot, () => {
+        const sourceStat = followedStatSync(absoluteSource, projectRoot);
+        if (sourceStat === undefined) {
+            throw packagingInputError(`files: source '${entry.source}' does not exist (resolved to ${anchoredPath(absoluteSource, projectRoot)}).${buildArtifactHint(entry.source)}`);
+        }
+        if (sourceStat.isDirectory()) {
+            throw packagingInputError(`files: source '${entry.source}' is a directory; use a glob like '${entry.source}/**/*' to copy its contents.`);
+        }
+    });
     // joinUnderRoot rejects a dest that escapes the skill output dir (absolute /
     // drive-letter / '..'), defense-in-depth beyond the schema refine.
     const absoluteDest = safePath.joinUnderRoot(skillOutputDir, entry.dest);
-    await mkdir(dirname(absoluteDest), { recursive: true });
-    await copyFile(absoluteSource, absoluteDest);
+    await copyEntryFile(entry, absoluteSource, { root: skillOutputDir, dest: absoluteDest }, projectRoot);
     return { relDest: normalizeRelPath(entry.dest), absSource: absoluteSource, absDest: absoluteDest };
 }
 /**
@@ -497,7 +511,7 @@ async function copyNonGlobEntry(entry, absoluteSource, projectRoot, skillOutputD
 async function expandGlobEntry(entry, projectRoot) {
     const remainder = globMagicRemainder(entry.source);
     if (hasParentTraversalSegment(remainder)) {
-        throw new Error(`files: source '${entry.source}' (glob) has a '..' segment in its glob portion ('${remainder}'); ` +
+        throw packagingInputError(`files: source '${entry.source}' (glob) has a '..' segment in its glob portion ('${remainder}'); ` +
             `parent-directory traversal is not allowed after the static base.`);
     }
     const absoluteBase = safePath.resolve(safePath.join(projectRoot, staticGlobBase(entry.source)));
@@ -550,17 +564,17 @@ async function expandGlobEntry(entry, projectRoot) {
 async function copyGlobEntry(entry, projectRoot, skillOutputDir) {
     const { absoluteBase, allMatches, kept: matches, droppedRel, dropped, nonRegularRel, nonRegular, } = await expandGlobEntry(entry, projectRoot);
     // Project-relative in both throws below: these messages are published verbatim
-    // as `failedSkills[].message` (see {@link anchoredPath}).
+    // as a `SKILL_PACKAGING_FAILED` finding's `message` (see {@link anchoredPath}).
     const reportedBase = anchoredPath(absoluteBase, projectRoot);
     if (allMatches.length === 0) {
-        throw new Error(`files: source '${entry.source}' (glob) matched no files under ${reportedBase} — has your build run?`);
+        throw packagingInputError(`files: source '${entry.source}' (glob) matched no files under ${reportedBase} — has your build run?`);
     }
     // Ordered BEFORE the never-package throw because it is the more specific
     // diagnosis: if the entry nets nothing shippable and nothing it netted was even
     // a file, "all of them are never packaged" names the wrong cause and its
     // remediation ("declare an explicit source: entry") would not work if followed.
     if (matches.length === 0 && droppedRel.length === 0) {
-        throw new Error(`files: source '${entry.source}' (glob) matched ${allMatches.length} path(s) under ${reportedBase}, ` +
+        throw packagingInputError(`files: source '${entry.source}' (glob) matched ${allMatches.length} path(s) under ${reportedBase}, ` +
             `but none of them is a regular file (a symlink to a directory, a FIFO, a socket or a device node ` +
             `cannot be packaged): ${nonRegularRel.join(', ')}. ` +
             `Point the glob at files, or replace the link with the directory it targets.`);
@@ -578,7 +592,7 @@ async function copyGlobEntry(entry, projectRoot, skillOutputDir) {
             ? ''
             : ` A further ${nonRegularRel.length.toString()} match(es) are not regular files and could not ` +
                 `be packaged either: ${nonRegularRel.join(', ')}.`;
-        throw new Error(`files: source '${entry.source}' (glob) matched ${allMatches.length} file(s) under ${reportedBase}, ` +
+        throw packagingInputError(`files: source '${entry.source}' (glob) matched ${allMatches.length} file(s) under ${reportedBase}, ` +
             `but all of them are never packaged into a skill bundle: ${droppedRel.join(', ')}. ` +
             // NOT "widen the glob": the filter is on basename and applies at any width, so a
             // wider glob clears this error while still shipping none of these files — advice
@@ -593,7 +607,8 @@ async function copyGlobEntry(entry, projectRoot, skillOutputDir) {
     // which equals the matched `rel` for files actually copied — the expected set
     // verifyDestSet diffs the on-disk subtree against.
     const rels = [];
-    for (const rel of matches) {
+    // In order: bundle writes, where the first failure names the first match.
+    await forEachInOrder(matches, async (rel) => {
         // joinUnderRoot asserts each matched file stays under absoluteBase (read) and
         // that the rebased dest stays under the skill output dir (write) — H1/H2
         // defense-in-depth against a traversal that slipped past earlier guards.
@@ -611,14 +626,11 @@ async function copyGlobEntry(entry, projectRoot, skillOutputDir) {
         // the author DECLARED and expects in the bundle, so shipping silently without
         // it would change the artifact behind their back. A non-regular match can
         // never be packaged at all, which is why that one degrades instead.
-        await attributed(entry, absSource, projectRoot, async () => {
-            await mkdir(dirname(absDest), { recursive: true });
-            await copyFile(absSource, absDest);
-        });
+        await copyEntryFile(entry, absSource, { root: skillOutputDir, dest: absDest }, projectRoot);
         copied.push(relDest);
         pairs.push({ absSource, absDest });
         rels.push(toForwardSlash(rel));
-    }
+    });
     return { copied, pairs, rels, dropped, skipped: nonRegular };
 }
 /**
@@ -666,9 +678,10 @@ export async function collectPreBuildGlobFindings(filesConfig, projectRoot) {
     const allRefused = [];
     const unmatched = [];
     const skipped = [];
-    for (const entry of filesConfig) {
+    // In order: `expandGlobEntry`'s throws must fire in `copyGlobEntry`'s order.
+    await forEachInOrder(filesConfig, async (entry) => {
         if (!isGlob(entry.source))
-            continue;
+            return;
         // A '..' segment in the magic remainder is a malformed pattern that
         // `expandGlobEntry` refuses to expand. It is the BUILD's error to raise (and
         // `copyGlobEntry` does); a pre-build gate asking "what would this do?" must not
@@ -683,7 +696,7 @@ export async function collectPreBuildGlobFindings(filesConfig, projectRoot) {
         // pattern in `SkillFileEntrySchema.source` the way `dest` already is — at which
         // point this line becomes defense-in-depth against a config that cannot load.
         if (hasParentTraversalSegment(globMagicRemainder(entry.source)))
-            continue;
+            return;
         const expansion = await expandGlobEntry(entry, projectRoot);
         const absBase = toForwardSlash(expansion.absoluteBase);
         // The two predicates below are `copyGlobEntry`'s two throws, in its order and
@@ -694,7 +707,7 @@ export async function collectPreBuildGlobFindings(filesConfig, projectRoot) {
         // exactly the misdirection the second error was written to avoid.
         if (expansion.allMatches.length === 0) {
             unmatched.push({ source: entry.source, absBase });
-            continue;
+            return;
         }
         // Reported for EVERY entry that has them, including ones that go on to be
         // `allRefused` below — unlike the per-file drops, which that verdict
@@ -706,7 +719,7 @@ export async function collectPreBuildGlobFindings(filesConfig, projectRoot) {
             // Matched only non-files. `allRefused` would name the never-package list as
             // the cause, which is not what happened, and its remediation would not work.
             // The `skipped` findings just pushed carry this entry on their own.
-            continue;
+            return;
         }
         if (expansion.kept.length === 0) {
             // Supersedes this entry's per-file drops rather than adding to them: the
@@ -718,10 +731,10 @@ export async function collectPreBuildGlobFindings(filesConfig, projectRoot) {
                 absBase,
                 absRefused: expansion.dropped.map((d) => d.absFile),
             });
-            continue;
+            return;
         }
         dropped.push(...expansion.dropped.filter((d) => !shippedDests.has(normalizeRelPath(d.dest))));
-    }
+    });
     return { dropped, allRefused, unmatched, skipped };
 }
 /**
@@ -798,7 +811,7 @@ function assertFileShapedDest(entry) {
     while (base.endsWith('/'))
         base = base.slice(0, -1);
     const suggested = `${base}/${entry.source.slice(entry.source.lastIndexOf('/') + 1)}`;
-    throw new Error(`files: dest '${entry.dest}' names a directory, but a non-glob entry copies ONE file to ONE path. ` +
+    throw packagingInputError(`files: dest '${entry.dest}' names a directory, but a non-glob entry copies ONE file to ONE path. ` +
         `Name the output file itself (e.g. dest: '${normalizeRelPath(suggested)}'), ` +
         `or use a glob source to copy a whole subtree.`);
 }
@@ -831,15 +844,7 @@ async function applyNonGlobFileEntry(fileEntry, opts, bundledFileSet) {
                 : undefined,
         };
     }
-    // The WHOLE entry's filesystem work is guarded, not just its copy. Guarding the
-    // copy alone left the source `statSync` outside — so a source under a directory
-    // the process cannot traverse still escaped as a bare errno, which is the same
-    // defect one call earlier. An EXPLICIT entry is the spelling that unambiguously
-    // says "ship this file", so a bare errno here is if anything worse than on a
-    // glob: the author named the path, and the build owes them an error that names
-    // it back. (`copyNonGlobEntry`'s own deliberate errors — "does not exist", "is a
-    // directory" — carry no errno, so `attributed` passes them through untouched.)
-    const { relDest, absSource, absDest } = await attributed(fileEntry, absoluteSource, opts.projectRoot, () => copyNonGlobEntry(fileEntry, absoluteSource, opts.projectRoot, opts.skillOutputDir));
+    const { relDest, absSource, absDest } = await copyNonGlobEntry(fileEntry, absoluteSource, opts.projectRoot, opts.skillOutputDir);
     return {
         dests: [relDest],
         dropped: [],
@@ -869,17 +874,16 @@ function relUnderDest(destRoot, dest) {
  * rather than being weakened into a permissive one.
  */
 async function runDeferredIntegrity(pending, allDests, skillOutputDir, projectRoot) {
-    for (const { entry, pairs, rels } of pending) {
-        // Through the same attribution point as the copy. `verifyFilesIntegrity`
-        // hashes both sides, so an unreadable source or dest surfaces here as a raw
-        // errno carrying an absolute path and no entry name — the same defect the
-        // copy loop had, in the one lane that had not been routed through the guard.
+    // In order: the first refusal is named in config order.
+    await forEachInOrder(pending, async ({ entry, pairs, rels }) => {
         // Anchored at the ENTRY, not at `pairs[0]`: any of the entry's files can be
         // the one that failed, and naming the first while the errno names another is
-        // worse than naming none. The errno itself carries the offending path.
-        await attributed(entry, safePath.resolve(safePath.join(projectRoot, entry.source)), projectRoot, async () => { verifyFilesIntegrity(pairs); }, 'verified');
+        // worse than naming none. The errno itself carries the offending path, and
+        // each read is coded by the tree it touched (see `verifyFilesIntegrity`).
+        const subject = entrySubject(entry, safePath.resolve(safePath.join(projectRoot, entry.source)), projectRoot);
+        verifyFilesIntegrity(subject, pairs);
         if (rels === undefined)
-            continue;
+            return;
         const destRoot = normalizeRelPath(entry.dest);
         const expected = new Set(rels);
         for (const dest of allDests) {
@@ -887,8 +891,10 @@ async function runDeferredIntegrity(pending, allDests, skillOutputDir, projectRo
             if (rel !== null && rel !== '')
                 expected.add(rel);
         }
-        await verifyDestSet(safePath.joinUnderRoot(skillOutputDir, entry.dest), [...expected], entry.source);
-    }
+        const destDir = safePath.joinUnderRoot(skillOutputDir, entry.dest);
+        // Lists the bundle the build just wrote: a refusal is the output's.
+        await withFsFault({ side: 'destination', shapeFromSource: true, action: `verify ${subject} in the bundle` }, () => verifyDestSet(destDir, [...expected], entry.source));
+    });
 }
 export async function applyFilesConfig(opts) {
     const bundledFileSet = new Set((opts.bundledFiles ?? []).map((f) => toForwardSlash(f)));
@@ -896,7 +902,8 @@ export async function applyFilesConfig(opts) {
     const dropped = [];
     const skipped = [];
     const pending = [];
-    for (const fileEntry of opts.filesConfig) {
+    // In order: ordered writes — a later entry may overwrite an earlier dest, and the last one wins.
+    await forEachInOrder(opts.filesConfig, async (fileEntry) => {
         const outcome = isGlob(fileEntry.source)
             ? await applyGlobFileEntry(fileEntry, opts)
             : await applyNonGlobFileEntry(fileEntry, opts, bundledFileSet);
@@ -905,7 +912,7 @@ export async function applyFilesConfig(opts) {
         skipped.push(...outcome.skipped);
         if (outcome.pending)
             pending.push(outcome.pending);
-    }
+    });
     await runDeferredIntegrity(pending, dests, opts.skillOutputDir, opts.projectRoot);
     // A drop is only worth reporting if the file genuinely did not ship. In the
     // escape-hatch config the guide prescribes — a glob over a subtree plus an