wingfoil 0.2.1

package/dist/core/types.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Core result & error shapes (spec-006-core-domain-api §2 — "Function shape").
+ *
+ * Every core function returns `Promise<CoreResult<T>>`, a discriminated union — never a thrown
+ * error for *expected* domain failures (illegal state transition, missing element, schema
+ * violation). That is what lets `src/cli`'s exit-code/stderr rendering and `src/mcp`'s Tool
+ * `isError`/Resource-read-failure response be driven off the very same value, rather than each
+ * surface independently deciding what counts as a failure and how to report it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreOk = coreOk;
+exports.coreErr = coreErr;
+/** Build a success {@link CoreResult}, optionally carrying the git commit the operation produced. */
+function coreOk(value, commit) {
+    return commit ? { ok: true, value, commit } : { ok: true, value };
+}
+/** Build a failure {@link CoreResult} from a {@link CoreError}. */
+function coreErr(error) {
+    return { ok: false, error };
+}
+//# sourceMappingURL=types.js.map

package/dist/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AA8BH,wBAEC;AAGD,0BAEC;AARD,qGAAqG;AACrG,SAAgB,MAAM,CAAI,KAAQ,EAAE,MAAyC;IAC3E,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACpE,CAAC;AAED,mEAAmE;AACnE,SAAgB,OAAO,CAAY,KAAgB;IACjD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAC9B,CAAC"}

package/dist/core/usage-error.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `UsageError` — a core operation's signal that its *arguments* were malformed (a usage/argument
+ * error, spec-005-cli-command-contract §1: "unknown flag, missing required argument, invalid flag
+ * value") as opposed to a business-logic failure. task-025-implement-dna-set introduces it for
+ * `dna set`'s invalid dotted key path (AC(c)), the first operation whose argument SHAPE must be
+ * interpreted inside the core function (a dotted path into `dna.yaml`) yet whose failure is classified
+ * as a usage error → exit **2**, not the exit **1** every `CoreError` maps to (`./exit-code.ts`).
+ *
+ * Why a thrown error rather than a `CoreResult.error`: the fixed `CoreError.code` enumeration
+ * (spec-006-core-domain-api §2) is all logic errors (exit 1) by design — `./exit-code.ts` documents
+ * that usage errors are deliberately not modeled there — so a usage error a core op detects is carried
+ * out to the single surface exit path as a throw, mapped by `exitCodeForThrow` (`./exit-code.ts`).
+ * `.message` is the clean, ready-to-render reason (spec-005 §3: `error: <reason>`), never a composite.
+ */
+export declare class UsageError extends Error {
+    /** Usage/argument error → exit 2 (spec-005-cli-command-contract §1, spec-008-cli-grammar §5). */
+    readonly exitCode = 2;
+    constructor(message: string);
+}
+//# sourceMappingURL=usage-error.d.ts.map

package/dist/core/usage-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-error.d.ts","sourceRoot":"","sources":["../../src/core/usage-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,iGAAiG;IACjG,QAAQ,CAAC,QAAQ,KAAK;gBAEV,OAAO,EAAE,MAAM;CAM5B"}

package/dist/core/usage-error.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageError = void 0;
+/**
+ * `UsageError` — a core operation's signal that its *arguments* were malformed (a usage/argument
+ * error, spec-005-cli-command-contract §1: "unknown flag, missing required argument, invalid flag
+ * value") as opposed to a business-logic failure. task-025-implement-dna-set introduces it for
+ * `dna set`'s invalid dotted key path (AC(c)), the first operation whose argument SHAPE must be
+ * interpreted inside the core function (a dotted path into `dna.yaml`) yet whose failure is classified
+ * as a usage error → exit **2**, not the exit **1** every `CoreError` maps to (`./exit-code.ts`).
+ *
+ * Why a thrown error rather than a `CoreResult.error`: the fixed `CoreError.code` enumeration
+ * (spec-006-core-domain-api §2) is all logic errors (exit 1) by design — `./exit-code.ts` documents
+ * that usage errors are deliberately not modeled there — so a usage error a core op detects is carried
+ * out to the single surface exit path as a throw, mapped by `exitCodeForThrow` (`./exit-code.ts`).
+ * `.message` is the clean, ready-to-render reason (spec-005 §3: `error: <reason>`), never a composite.
+ */
+class UsageError extends Error {
+    /** Usage/argument error → exit 2 (spec-005-cli-command-contract §1, spec-008-cli-grammar §5). */
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = 'UsageError';
+        // Restore the prototype chain so `instanceof UsageError` holds after transpilation.
+        Object.setPrototypeOf(this, UsageError.prototype);
+    }
+}
+exports.UsageError = UsageError;
+//# sourceMappingURL=usage-error.js.map

package/dist/core/usage-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-error.js","sourceRoot":"","sources":["../../src/core/usage-error.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;GAaG;AACH,MAAa,UAAW,SAAQ,KAAK;IACnC,iGAAiG;IACxF,QAAQ,GAAG,CAAC,CAAC;IAEtB,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,oFAAoF;QACpF,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;CACF;AAVD,gCAUC"}

package/dist/core/write-guard.d.ts

@@ -0,0 +1,99 @@
+import { type CoreResult } from './types';
+/** How a refusal names the operation whose commit a dirty target would otherwise enlarge. */
+export interface WriteTargetContract {
+    /** What the file is called in the message — `'document'` for Memory, `'file'` for configuration. */
+    readonly noun: string;
+    /** Fills "modifications this `<owner>` does not own" — e.g. `'transition'`, `'operation'`. */
+    readonly owner: string;
+    /** One clause saying what this kind of commit records, without a trailing separator. */
+    readonly records: string;
+}
+/** The contract every non-transition write verb refuses under (`dna set`, the `directive` verbs, `init`). */
+export declare const CONFIG_WRITE_CONTRACT: WriteTargetContract;
+/**
+ * Refuse, before anything is written, a target that already carries modifications this operation
+ * does not own — `dl-080`'s ratified write rule for a command that **edits a file in place**.
+ *
+ * Both of the user's declarations are inspected, the index (`:0`) and the working tree, because they
+ * can disagree and `commitPaths`'s `git add -- <path>` would silently replace the former with the
+ * latter. The refusal names the `git status` code and what is different, so the user can act on it
+ * without re-deriving it.
+ *
+ * **Why refusing rather than committing only the operation's own hunk.** Settled by `task-088` and
+ * ratified by `dl-080`, not re-argued here: partial staging is undefined before it is difficult
+ * (there are two candidate baselines on disk and "only my hunk" does not say onto which), and the
+ * edits it would leave behind are invisible, deferred, and swept into whatever commits next. A
+ * refusal costs two commands, now, on a file this function has provably not touched.
+ *
+ * @param worktree - The working-tree text when the caller has already read it (the transition verbs
+ *   have); omitted, it is read here.
+ */
+export declare function requireUnmodifiedTarget(root: string, path: string, contract?: WriteTargetContract, worktree?: string): CoreResult<undefined>;
+/** {@link requireUnmodifiedTarget} over several targets, refusing on the first one that is dirty. */
+export declare function requireUnmodifiedTargets(root: string, paths: readonly string[], contract?: WriteTargetContract): CoreResult<undefined>;
+/**
+ * Refuse, before anything is written, a target that is supposed to be **new** but is already
+ * occupied — `dl-080`'s write rule in the shape a *creating* command needs (`memory add`).
+ *
+ * "Unmodified" is the wrong question for a command whose contract is to register a new element: the
+ * path is normally absent, so the modification it does not own is any pre-existing content at all.
+ * `pathPorcelainStatus` cannot answer this on its own — it reports the empty string both for an
+ * absent path and for a clean, tracked one — so each of the three places a file can live is checked
+ * explicitly.
+ *
+ * Reachable because `memory add` derives its id's sequence number from `readdirSync` of the working
+ * tree (`nextSequenceNumber`, `../memory/add.ts`), so a working tree that disagrees with `HEAD` about
+ * how many elements exist can generate an id that lands on an occupied path; the write that follows
+ * is unconditional, and the commit's diff then becomes `HEAD` → scaffold rather than absent →
+ * scaffold. A commit whose subject says "add" and whose diff removes lines is `bug-078` at its
+ * sharpest.
+ *
+ * @param path - Root-relative POSIX path of the file about to be created.
+ */
+export declare function requireAbsentTarget(root: string, path: string): CoreResult<undefined>;
+/**
+ * The paths a commit changed against its own parent that are **not** among `declared`, with the
+ * parent it was compared against. The parent is `<sha>^`, or git's empty tree for a root commit, so
+ * the comparison is total rather than conditional.
+ *
+ * Extracted so `verifyCommittedScope` (the Memory transition post-condition, `./memory-transition.ts`)
+ * and {@link verifyCommittedPaths} (its content-agnostic sibling, below) share one answer to "did
+ * anything else ride in".
+ */
+export declare function undeclaredCommittedPaths(root: string, sha: string, declared: readonly string[]): {
+    parent: string;
+    problems: string[];
+};
+/**
+ * Verify what a commit **contains**, by diffing it against its own parent — the content-agnostic
+ * sibling of `verifyCommittedScope` (`./memory-transition.ts`), for targets that carry no declared
+ * frontmatter fields.
+ *
+ * `verifyCommittedScope` delegates its content half to `verifyDocumentEdit`, which compares *owned
+ * frontmatter fields* and a body. `dna.yaml` and `roles.yaml` have no frontmatter block at all, so
+ * for them the right — and strictly stronger — question is byte equality: the commit must carry, for
+ * each declared path, exactly the text this operation wrote, and nothing else.
+ *
+ * Same shape as `task-080`'s lockfile guard and `task-088`'s post-condition: assert the diff, not the
+ * end state. Reading the file back from disk answers "does `dna.yaml` now say `Renamed`?" — true no
+ * matter what else rode along.
+ *
+ * It is an **alarm, not a rollback**: it can only run once the commit exists, and rewriting history
+ * behind the user's back is a worse failure than reporting one (`dl-035` points the same way). With
+ * {@link requireUnmodifiedTarget} in place no argument to a verb can reach it; a repository-local
+ * `pre-commit` hook that rewrites and re-stages the file still can, which is precisely what it is for.
+ *
+ * @param expected - Each root-relative path the commit must carry, mapped to the exact content it
+ *   must have there, or `null` when the commit must have **removed** it. Iterated in insertion order
+ *   (REQ-SYS-07: a caller's fixed order produces a fixed problem order).
+ * @returns The problems found, empty when the commit carries exactly the declared change.
+ */
+export declare function verifyCommittedPaths(root: string, sha: string, expected: ReadonlyMap<string, string | null>): string[];
+/**
+ * {@link verifyCommittedPaths} for the common single-path case, rendered as the `CoreResult.error`
+ * every caller returns — `undefined` when the commit is exactly what was declared.
+ *
+ * @param content - The text the operation wrote, or `null` when it removed the path.
+ */
+export declare function committedScopeError(root: string, sha: string, path: string, content: string | null): CoreResult<never> | undefined;
+//# sourceMappingURL=write-guard.d.ts.map

package/dist/core/write-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-guard.d.ts","sourceRoot":"","sources":["../../src/core/write-guard.ts"],"names":[],"mappings":"AAsDA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE3D,6FAA6F;AAC7F,MAAM,WAAW,mBAAmB;IAClC,oGAAoG;IACpG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8FAA8F;IAC9F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,6GAA6G;AAC7G,eAAO,MAAM,qBAAqB,EAAE,mBAInC,CAAC;AA2BF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,mBAA2C,EACrD,QAAQ,CAAC,EAAE,MAAM,GAChB,UAAU,CAAC,SAAS,CAAC,CAwBvB;AAED,qGAAqG;AACrG,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,QAAQ,GAAE,mBAA2C,GACpD,UAAU,CAAC,SAAS,CAAC,CAMvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,SAAS,CAAC,CAcrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAMxC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,GAC3C,MAAM,EAAE,CAaV;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,UAAU,CAAC,KAAK,CAAC,GAAG,SAAS,CAO/B"}

package/dist/core/write-guard.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_WRITE_CONTRACT = void 0;
+exports.requireUnmodifiedTarget = requireUnmodifiedTarget;
+exports.requireUnmodifiedTargets = requireUnmodifiedTargets;
+exports.requireAbsentTarget = requireAbsentTarget;
+exports.undeclaredCommittedPaths = undeclaredCommittedPaths;
+exports.verifyCommittedPaths = verifyCommittedPaths;
+exports.committedScopeError = committedScopeError;
+/**
+ * The write-side half of `dl-080-which-baseline-each-command-reads`, ratified as option **(B)**:
+ * *a write refuses while its target carries modifications the command does not own*
+ * (task-092-writes-refuse-a-dirty-target, `bug-078`).
+ *
+ * `task-088` landed that rule for the four gated Memory transition verbs, where the target is a
+ * Memory document and "what the verb owns" is a named set of frontmatter fields. `commitPaths` has
+ * six other callers — `dna set`, `directive create`, `directive assign`, `directive remove`,
+ * `wingfoil init`'s scaffold and `memory add` — whose targets are ordinary config files and brand-new
+ * documents, so the same rule needs two shapes rather than one:
+ *
+ * - {@link requireUnmodifiedTarget} — for a target the command **edits in place**. It must be
+ *   identical in `HEAD`, in the index and in the working tree; anything else is a modification the
+ *   command did not make and must not commit.
+ * - {@link requireAbsentTarget} — for a target the command **creates**. "Unmodified" is the wrong
+ *   question there: the path is supposed to be new, so the rule is that nothing may already occupy
+ *   it, in `HEAD`, in the index or in the working tree.
+ *
+ * Both are composed from the same primitives `task-088` introduced for the transition verbs —
+ * `pathPorcelainStatus`, `readPathAtRev`, `commitParent`, `changedPathsBetween` (`../storage`) and
+ * `describeDocumentChanges` (`../memory`) — and `requireUnmodifiedDocument` in `./memory-transition.ts`
+ * is itself re-expressed as a call into {@link requireUnmodifiedTarget}, so there is **one** gate in
+ * the codebase rather than two that can drift. What varies per call site is only the wording of the
+ * refusal, carried in a {@link WriteTargetContract}.
+ *
+ * **Why git's own answer decides "is it modified".** `pathPorcelainStatus` runs `git status
+ * --porcelain -- <path>`: git owns index refresh, `core.autocrlf` and `.gitattributes` filters, and
+ * an answer re-derived from bytes would disagree with `git status` on exactly the machines where
+ * that matters.
+ *
+ * **Why the guard is per-path and never per-tree.** `commitPaths` commits with
+ * `git commit --only -- <paths>` (`bug-027`), so an unrelated dirty file cannot ride into the commit
+ * in the first place. Refusing on one would be `dl-080`'s option (D), which its ratification
+ * rejected: "an unrelated uncommitted edit blocks a verb, so designing a new type in `memory.yaml`
+ * would prevent approving an element that has nothing to do with it".
+ *
+ * **Exit code.** Every refusal here is a `CoreResult.error` with `code: 'VALIDATION'`, which
+ * `exitCodeForError` maps to **1**. `spec-005-cli-command-contract` § "1. Exit-code contract
+ * (REQ-INT-04)" reserves `2` for a malformed *invocation*; a dirty target is a repository-state
+ * precondition, and re-typing the command cannot help. That is the ruling recorded on `bug-076`.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const memory_1 = require("../memory");
+const storage_1 = require("../storage");
+const types_1 = require("./types");
+/** The contract every non-transition write verb refuses under (`dna set`, the `directive` verbs, `init`). */
+exports.CONFIG_WRITE_CONTRACT = {
+    noun: 'file',
+    owner: 'operation',
+    records: 'A `wf(...)` commit records the change its subject declares and nothing else',
+};
+/**
+ * Name, in a form a person can act on, how `after` differs from `before` at `HEAD`.
+ *
+ * Delegates to {@link describeDocumentChanges} — which reports the frontmatter fields that moved and
+ * whether the body moved — but only for a file that actually HAS a frontmatter block. `dna.yaml` and
+ * `roles.yaml` have none (`splitFrontmatter` returns `{frontmatter: null}` and puts the whole file in
+ * `body`), and reporting "the body" for a YAML configuration file reads wrong; those get the honest
+ * `'the file content'` instead. Directive documents DO carry frontmatter, so they keep the
+ * field-level detail.
+ */
+function describeTargetChanges(before, after, noun) {
+    if (before === null)
+        return [`the ${noun} is not tracked at HEAD`];
+    if (before === after)
+        return [];
+    if ((0, storage_1.splitFrontmatter)(before).frontmatter === null && (0, storage_1.splitFrontmatter)(after).frontmatter === null) {
+        return [`the ${noun} content`];
+    }
+    return (0, memory_1.describeDocumentChanges)(before, after);
+}
+/** The working-tree text of `path`, or `null` when it is absent from the working tree. */
+function readWorktree(root, path) {
+    const absolute = (0, node_path_1.join)(root, path);
+    return (0, node_fs_1.existsSync)(absolute) ? (0, storage_1.readDocument)(absolute) : null;
+}
+/**
+ * Refuse, before anything is written, a target that already carries modifications this operation
+ * does not own — `dl-080`'s ratified write rule for a command that **edits a file in place**.
+ *
+ * Both of the user's declarations are inspected, the index (`:0`) and the working tree, because they
+ * can disagree and `commitPaths`'s `git add -- <path>` would silently replace the former with the
+ * latter. The refusal names the `git status` code and what is different, so the user can act on it
+ * without re-deriving it.
+ *
+ * **Why refusing rather than committing only the operation's own hunk.** Settled by `task-088` and
+ * ratified by `dl-080`, not re-argued here: partial staging is undefined before it is difficult
+ * (there are two candidate baselines on disk and "only my hunk" does not say onto which), and the
+ * edits it would leave behind are invisible, deferred, and swept into whatever commits next. A
+ * refusal costs two commands, now, on a file this function has provably not touched.
+ *
+ * @param worktree - The working-tree text when the caller has already read it (the transition verbs
+ *   have); omitted, it is read here.
+ */
+function requireUnmodifiedTarget(root, path, contract = exports.CONFIG_WRITE_CONTRACT, worktree) {
+    const porcelain = (0, storage_1.pathPorcelainStatus)(root, path);
+    if (porcelain === '')
+        return (0, types_1.coreOk)(undefined);
+    const atHead = (0, storage_1.readPathAtRev)(root, 'HEAD', path);
+    const named = new Set();
+    const candidates = [
+        [(0, storage_1.readPathAtRev)(root, ':0', path), `the ${contract.noun} is not in the index`],
+        [worktree ?? readWorktree(root, path), `the ${contract.noun} is not in the working tree`],
+    ];
+    for (const [candidate, absent] of candidates) {
+        if (candidate === null) {
+            named.add(absent);
+            continue;
+        }
+        for (const change of describeTargetChanges(atHead, candidate, contract.noun))
+            named.add(change);
+    }
+    return (0, types_1.coreErr)({
+        code: 'VALIDATION',
+        message: `refusing to commit ${path}: it carries uncommitted modifications this ${contract.owner} does not own ` +
+            `[git status '${porcelain}'] — ${[...named].sort().join(', ')}. ${contract.records}; commit or stash ` +
+            'these changes first, then retry.',
+    });
+}
+/** {@link requireUnmodifiedTarget} over several targets, refusing on the first one that is dirty. */
+function requireUnmodifiedTargets(root, paths, contract = exports.CONFIG_WRITE_CONTRACT) {
+    for (const path of paths) {
+        const clean = requireUnmodifiedTarget(root, path, contract);
+        if (!clean.ok)
+            return clean;
+    }
+    return (0, types_1.coreOk)(undefined);
+}
+/**
+ * Refuse, before anything is written, a target that is supposed to be **new** but is already
+ * occupied — `dl-080`'s write rule in the shape a *creating* command needs (`memory add`).
+ *
+ * "Unmodified" is the wrong question for a command whose contract is to register a new element: the
+ * path is normally absent, so the modification it does not own is any pre-existing content at all.
+ * `pathPorcelainStatus` cannot answer this on its own — it reports the empty string both for an
+ * absent path and for a clean, tracked one — so each of the three places a file can live is checked
+ * explicitly.
+ *
+ * Reachable because `memory add` derives its id's sequence number from `readdirSync` of the working
+ * tree (`nextSequenceNumber`, `../memory/add.ts`), so a working tree that disagrees with `HEAD` about
+ * how many elements exist can generate an id that lands on an occupied path; the write that follows
+ * is unconditional, and the commit's diff then becomes `HEAD` → scaffold rather than absent →
+ * scaffold. A commit whose subject says "add" and whose diff removes lines is `bug-078` at its
+ * sharpest.
+ *
+ * @param path - Root-relative POSIX path of the file about to be created.
+ */
+function requireAbsentTarget(root, path) {
+    const occupied = [];
+    if ((0, storage_1.readPathAtRev)(root, 'HEAD', path) !== null)
+        occupied.push('at HEAD');
+    if ((0, storage_1.readPathAtRev)(root, ':0', path) !== null)
+        occupied.push('in the index');
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, path)))
+        occupied.push('in the working tree');
+    if (occupied.length === 0)
+        return (0, types_1.coreOk)(undefined);
+    return (0, types_1.coreErr)({
+        code: 'VALIDATION',
+        message: `refusing to create ${path}: something already exists there (${occupied.join(', ')}). This operation ` +
+            'registers a NEW element, so writing over an existing file would produce a commit carrying changes its ' +
+            'subject does not declare; move or commit what is there first, or choose a different title.',
+    });
+}
+/**
+ * The paths a commit changed against its own parent that are **not** among `declared`, with the
+ * parent it was compared against. The parent is `<sha>^`, or git's empty tree for a root commit, so
+ * the comparison is total rather than conditional.
+ *
+ * Extracted so `verifyCommittedScope` (the Memory transition post-condition, `./memory-transition.ts`)
+ * and {@link verifyCommittedPaths} (its content-agnostic sibling, below) share one answer to "did
+ * anything else ride in".
+ */
+function undeclaredCommittedPaths(root, sha, declared) {
+    const parent = (0, storage_1.commitParent)(root, sha);
+    const problems = (0, storage_1.changedPathsBetween)(root, parent, sha)
+        .filter((changed) => !declared.includes(changed))
+        .map((changed) => `it also contains '${changed}'`);
+    return { parent, problems };
+}
+/**
+ * Verify what a commit **contains**, by diffing it against its own parent — the content-agnostic
+ * sibling of `verifyCommittedScope` (`./memory-transition.ts`), for targets that carry no declared
+ * frontmatter fields.
+ *
+ * `verifyCommittedScope` delegates its content half to `verifyDocumentEdit`, which compares *owned
+ * frontmatter fields* and a body. `dna.yaml` and `roles.yaml` have no frontmatter block at all, so
+ * for them the right — and strictly stronger — question is byte equality: the commit must carry, for
+ * each declared path, exactly the text this operation wrote, and nothing else.
+ *
+ * Same shape as `task-080`'s lockfile guard and `task-088`'s post-condition: assert the diff, not the
+ * end state. Reading the file back from disk answers "does `dna.yaml` now say `Renamed`?" — true no
+ * matter what else rode along.
+ *
+ * It is an **alarm, not a rollback**: it can only run once the commit exists, and rewriting history
+ * behind the user's back is a worse failure than reporting one (`dl-035` points the same way). With
+ * {@link requireUnmodifiedTarget} in place no argument to a verb can reach it; a repository-local
+ * `pre-commit` hook that rewrites and re-stages the file still can, which is precisely what it is for.
+ *
+ * @param expected - Each root-relative path the commit must carry, mapped to the exact content it
+ *   must have there, or `null` when the commit must have **removed** it. Iterated in insertion order
+ *   (REQ-SYS-07: a caller's fixed order produces a fixed problem order).
+ * @returns The problems found, empty when the commit carries exactly the declared change.
+ */
+function verifyCommittedPaths(root, sha, expected) {
+    const { problems } = undeclaredCommittedPaths(root, sha, [...expected.keys()]);
+    for (const [path, content] of expected) {
+        const after = (0, storage_1.readPathAtRev)(root, sha, path);
+        if (content === null) {
+            if (after !== null)
+                problems.push(`it still contains '${path}', which this operation removed`);
+        }
+        else if (after === null) {
+            problems.push(`it does not contain '${path}'`);
+        }
+        else if (after !== content) {
+            problems.push(`'${path}' at the commit differs from what this operation wrote`);
+        }
+    }
+    return problems;
+}
+/**
+ * {@link verifyCommittedPaths} for the common single-path case, rendered as the `CoreResult.error`
+ * every caller returns — `undefined` when the commit is exactly what was declared.
+ *
+ * @param content - The text the operation wrote, or `null` when it removed the path.
+ */
+function committedScopeError(root, sha, path, content) {
+    const leaked = verifyCommittedPaths(root, sha, new Map([[path, content]]));
+    if (leaked.length === 0)
+        return undefined;
+    return (0, types_1.coreErr)({
+        code: 'VALIDATION',
+        message: `commit ${sha} carries more than the change it declares: ${leaked.join('; ')}`,
+    });
+}
+//# sourceMappingURL=write-guard.js.map

package/dist/core/write-guard.js.map

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

package/dist/directives/create.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure Directives-pillar helpers for `wingfoil directive create` (P3.1,
+ * task-050-directive-create). The `directives` pillar owns what a directive is *called* and what a
+ * newly-created directive file *contains*; `src/core`'s `directiveCreate` operation composes these
+ * with the git-identity pre-flight, the already-exists check, the write and the commit (cross-pillar
+ * / storage concerns that therefore live in `src/core`, not here). Nothing in this file imports
+ * `src/core` or touches the filesystem — the pillar stays a leaf under core
+ * (spec-006-core-domain-api §1) and every function here is pure (REQ-SYS-07: no wall-clock, no
+ * randomness, no environment read), so the same `--name` always yields byte-identical output.
+ *
+ * The generated frontmatter is a contract, not a formality: it must satisfy
+ * {@link DirectiveFrontmatter} (spec-013-directive-frontmatter-schema) so a created directive loads
+ * cleanly through `loadDirectives` alongside the ten `wingfoil init` scaffolds — `bug-006` was
+ * precisely that invariant broken from the init-generator side.
+ */
+/**
+ * The exact refusal message P3.1's "Error - invalid directive name" scenario pins
+ * (`docs/02_requirements/02_bdd/features/p3-directives/P3.1-directive-create.feature`) — surfaced by
+ * `src/core` as a `UsageError`, hence exit `2` (spec-008-cli-grammar §5). Do not reword.
+ */
+export declare const INVALID_DIRECTIVE_NAME_MESSAGE = "invalid directive name (use kebab-case)";
+/** Whether `name` is a legal custom-directive name (kebab-case — see {@link DIRECTIVE_NAME_RE}). */
+export declare function isValidDirectiveName(name: string): boolean;
+/**
+ * The human-readable title generated from a kebab-case directive name: hyphens become spaces and the
+ * first character is upper-cased (`no-direct-db-access` -> `No direct db access`). Deliberately the
+ * same shape `wingfoil init`'s own directive generator uses for its scaffolds (`code-quality` ->
+ * `Code quality`, `src/storage/templates.ts`), so a created directive is indistinguishable in style
+ * from a scaffolded one. A pure function of `name`; assumes {@link isValidDirectiveName} already
+ * passed (the caller validates first).
+ */
+export declare function directiveTitleFromName(name: string): string;
+/**
+ * The full Markdown document written for a new custom directive: a YAML frontmatter block that
+ * satisfies `DirectiveFrontmatter` (spec-013 — `id`, `name`, `type`, `kind`, `title` are the required
+ * fields) followed by a placeholder body for the rule text.
+ *
+ * - `id` is the name verbatim, matching the filename stem the caller writes (spec-013's `id` note).
+ * - `kind: custom` because the file lands under `directives/custom/` (spec-011's built-in/custom split;
+ *   `built-in/` is reserved for the P3.8 templates the package will ship).
+ * - `tags`/`ref` are omitted: both are `.optional()` in the schema, and a user-authored rule has no
+ *   upstream P3.8 reference to claim.
+ *
+ * The body is deliberately not schema-governed (spec-013: "Body content is not governed here").
+ */
+export declare function renderCustomDirective(name: string): string;
+//# sourceMappingURL=create.d.ts.map

package/dist/directives/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/directives/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,4CAA4C,CAAC;AAExF,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc1D"}

package/dist/directives/create.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Pure Directives-pillar helpers for `wingfoil directive create` (P3.1,
+ * task-050-directive-create). The `directives` pillar owns what a directive is *called* and what a
+ * newly-created directive file *contains*; `src/core`'s `directiveCreate` operation composes these
+ * with the git-identity pre-flight, the already-exists check, the write and the commit (cross-pillar
+ * / storage concerns that therefore live in `src/core`, not here). Nothing in this file imports
+ * `src/core` or touches the filesystem — the pillar stays a leaf under core
+ * (spec-006-core-domain-api §1) and every function here is pure (REQ-SYS-07: no wall-clock, no
+ * randomness, no environment read), so the same `--name` always yields byte-identical output.
+ *
+ * The generated frontmatter is a contract, not a formality: it must satisfy
+ * {@link DirectiveFrontmatter} (spec-013-directive-frontmatter-schema) so a created directive loads
+ * cleanly through `loadDirectives` alongside the ten `wingfoil init` scaffolds — `bug-006` was
+ * precisely that invariant broken from the init-generator side.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_DIRECTIVE_NAME_MESSAGE = void 0;
+exports.isValidDirectiveName = isValidDirectiveName;
+exports.directiveTitleFromName = directiveTitleFromName;
+exports.renderCustomDirective = renderCustomDirective;
+/**
+ * A directive name is kebab-case: one or more lower-case alphanumeric segments joined by single
+ * hyphens. No upper case, no leading/trailing/doubled hyphen, no whitespace, dot, underscore or path
+ * separator.
+ *
+ * Rejecting everything else also makes the write target unescapable by construction: `..`, `../x`,
+ * `a/b` and `/etc/passwd` all fail this rule *before* `src/core` builds any path from the name, so
+ * the created file can only ever land directly inside `.wingfoil/directives/custom/`.
+ */
+const DIRECTIVE_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/**
+ * The exact refusal message P3.1's "Error - invalid directive name" scenario pins
+ * (`docs/02_requirements/02_bdd/features/p3-directives/P3.1-directive-create.feature`) — surfaced by
+ * `src/core` as a `UsageError`, hence exit `2` (spec-008-cli-grammar §5). Do not reword.
+ */
+exports.INVALID_DIRECTIVE_NAME_MESSAGE = 'invalid directive name (use kebab-case)';
+/** Whether `name` is a legal custom-directive name (kebab-case — see {@link DIRECTIVE_NAME_RE}). */
+function isValidDirectiveName(name) {
+    return DIRECTIVE_NAME_RE.test(name);
+}
+/**
+ * The human-readable title generated from a kebab-case directive name: hyphens become spaces and the
+ * first character is upper-cased (`no-direct-db-access` -> `No direct db access`). Deliberately the
+ * same shape `wingfoil init`'s own directive generator uses for its scaffolds (`code-quality` ->
+ * `Code quality`, `src/storage/templates.ts`), so a created directive is indistinguishable in style
+ * from a scaffolded one. A pure function of `name`; assumes {@link isValidDirectiveName} already
+ * passed (the caller validates first).
+ */
+function directiveTitleFromName(name) {
+    const words = name.replace(/-/g, ' ');
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+/**
+ * The full Markdown document written for a new custom directive: a YAML frontmatter block that
+ * satisfies `DirectiveFrontmatter` (spec-013 — `id`, `name`, `type`, `kind`, `title` are the required
+ * fields) followed by a placeholder body for the rule text.
+ *
+ * - `id` is the name verbatim, matching the filename stem the caller writes (spec-013's `id` note).
+ * - `kind: custom` because the file lands under `directives/custom/` (spec-011's built-in/custom split;
+ *   `built-in/` is reserved for the P3.8 templates the package will ship).
+ * - `tags`/`ref` are omitted: both are `.optional()` in the schema, and a user-authored rule has no
+ *   upstream P3.8 reference to claim.
+ *
+ * The body is deliberately not schema-governed (spec-013: "Body content is not governed here").
+ */
+function renderCustomDirective(name) {
+    const title = directiveTitleFromName(name);
+    return `---
+id: ${name}
+name: ${name}
+type: directive
+kind: custom
+title: "${title}"
+---
+
+# ${title}
+
+<!-- Write the rule this directive enforces here. Directives are auto-loaded per role (roles.yaml). -->
+`;
+}
+//# sourceMappingURL=create.js.map

package/dist/directives/create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../src/directives/create.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAqBH,oDAEC;AAUD,wDAGC;AAeD,sDAcC;AA/DD;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,4BAA4B,CAAC;AAEvD;;;;GAIG;AACU,QAAA,8BAA8B,GAAG,yCAAyC,CAAC;AAExF,oGAAoG;AACpG,SAAgB,oBAAoB,CAAC,IAAY;IAC/C,OAAO,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CAAC,IAAY;IACjD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACtC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,qBAAqB,CAAC,IAAY;IAChD,MAAM,KAAK,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC3C,OAAO;MACH,IAAI;QACF,IAAI;;;UAGF,KAAK;;;IAGX,KAAK;;;CAGR,CAAC;AACF,CAAC"}

package/dist/directives/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `directives` module — Project Directives pillar; role-based rules (built-in + custom) (P3.5/P3.8).
+ * `DirectiveFrontmatter` (an [AUTHORING]-level minimal schema — see `./schema` for why there is no
+ * dedicated tech-spec yet) lives here — the pillar owns its own independent schema (REQ-SYS-02);
+ * `src/core`'s loader wires it through the shared validation pipeline. `./create`
+ * (task-050-directive-create, P3.1) adds the pillar's first *authoring* helpers — the kebab-case
+ * name rule and the generated file's content — which `src/core`'s `directiveCreate` operation
+ * composes with the git-identity pre-flight, write and commit. `./roles-edit`
+ * (task-051-directive-assign, P3.2) adds the pure, comment-preserving `roles.yaml` assignment edit that
+ * `src/core`'s `directiveAssign` writes through, and `parseDirectiveIds`
+ * (task-056-role-based-directive-assignment, P3.7) the comma-separated `--directive` value parser that
+ * makes the same verb bind several directives at once. `directive remove` (P3.3, task-052) reuses none
+ * of it — it refuses a still-assigned directive rather than unbinding it. Further Directives behavior
+ * lands in later tasks.
+ */
+export declare const MODULE_NAME: "directives";
+export { DirectiveFrontmatter, RolesYaml } from './schema';
+export { INVALID_DIRECTIVE_NAME_MESSAGE, directiveTitleFromName, isValidDirectiveName, renderCustomDirective, } from './create';
+export { parseDirectiveIds, setRoleAssignmentsInText, withAssignedDirectives } from './roles-edit';
+//# sourceMappingURL=index.d.ts.map

package/dist/directives/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/directives/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,EAAG,YAAqB,CAAC;AAEjD,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE3D,OAAO,EACL,8BAA8B,EAC9B,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC"}