wingfoil 0.2.1

package/dist/memory/submit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit.d.ts","sourceRoot":"","sources":["../../src/memory/submit.ts"],"names":[],"mappings":"AAcA,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AAUzD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAG3H;AAED,6GAA6G;AAC7G,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE5E"}

package/dist/memory/submit.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REJECTION_REASON_FIELD = void 0;
+exports.missingRequiredFields = missingRequiredFields;
+exports.renderSubmitDocument = renderSubmitDocument;
+/**
+ * Pure helpers behind `wingfoil memory submit` (P1.6, task-045-memory-submit), kept out of the
+ * `CoreResult`-wrapped operation in `src/core` the same way `./add.ts` serves `memory add`.
+ *
+ * Both implement `spec-010-memory-frontmatter-schema`:
+ * - "Validation rules": `title`, and every field in the type's `template.frontmatter.required`, must
+ *   be non-empty once `status` is anything other than `draft` — so a submit checks them first.
+ * - "Field-write ownership": `memory.submit` moves `status` to the next state and clears
+ *   `rejection_reason` by removing the key (it mirrors only the most recent reject).
+ *
+ * Deterministic (REQ-SYS-07): results follow the declared field order, never object-key order.
+ */
+const frontmatter_edit_1 = require("./frontmatter-edit");
+/** The frontmatter key `memory.reject` sets and `memory.submit` removes (spec-010). */
+exports.REJECTION_REASON_FIELD = 'rejection_reason';
+/** Absent, `null`, a blank string or an empty list count as "not filled in". */
+function isEmptyValue(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
+/**
+ * The fields that must be filled before a submit but are not: `title` first (spec-010 requires it of
+ * every type), then each of `required` in its declared order, without duplicates. `[]` means the
+ * document may be submitted.
+ */
+function missingRequiredFields(frontmatter, required) {
+    const fields = [...new Set(['title', ...required])];
+    return fields.filter((field) => isEmptyValue(frontmatter[field]));
+}
+/** The submitted document: `status` set to `target` and `rejection_reason` removed; nothing else changes. */
+function renderSubmitDocument(content, target) {
+    return (0, frontmatter_edit_1.removeFrontmatterField)((0, frontmatter_edit_1.setFrontmatterField)(content, 'status', target), exports.REJECTION_REASON_FIELD);
+}
+//# sourceMappingURL=submit.js.map

package/dist/memory/submit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit.js","sourceRoot":"","sources":["../../src/memory/submit.ts"],"names":[],"mappings":";;;AA8BA,sDAGC;AAGD,oDAEC;AAtCD;;;;;;;;;;;GAWG;AACH,yDAAiF;AAEjF,uFAAuF;AAC1E,QAAA,sBAAsB,GAAG,kBAAkB,CAAC;AAEzD,gFAAgF;AAChF,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACvD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;IAChE,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;IACpD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CAAC,WAA8C,EAAE,QAA2B;IAC/G,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACpE,CAAC;AAED,6GAA6G;AAC7G,SAAgB,oBAAoB,CAAC,OAAe,EAAE,MAAc;IAClE,OAAO,IAAA,yCAAsB,EAAC,IAAA,sCAAmB,EAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,8BAAsB,CAAC,CAAC;AACxG,CAAC"}

package/dist/storage/builtin-directives.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The official built-in directive templates (P3.8, US-0A-09 — `task-057-builtin-directive-templates`):
+ * Code Quality, Testing, Code Review, Architecture, Security, Documentation.
+ *
+ * **Where they live and how they reach a project.** `spec-011-storage-layout` reserves
+ * `.wingfoil/directives/built-in/` for "the official P3.8 directive templates shipped by the `wingfoil`
+ * npm package", and `spec-015-packaging-publishing` §1 keeps the tarball allowlist at
+ * `files: ["dist", "README.md"]` — so the templates ship as DATA compiled into `dist/`, not as loose
+ * Markdown beside it. `templateScaffold` (./templates) renders them into the `ScaffoldFile[]` that
+ * `wingfoil init` writes, which is also the list `initWingfoilProject` schema-checks first (REQ-SEC-10,
+ * derived by `builtinTemplateSources`): adding or editing a template here is automatically checked.
+ *
+ * **Frontmatter** (`spec-013-directive-frontmatter-schema`): exactly the declared keys `id` (the filename
+ * stem), `name`, `type: directive`, `kind: built-in`, `title`, `tags`, `ref: [P3.8]`. No other key: an
+ * undeclared key rides `.passthrough()` and prints an `unknown field(s) ignored` warning on stderr during
+ * every `init` (task-044's hand-off).
+ *
+ * **Body**: normative, project-agnostic rules for AI agents and humans. Deliberately free of any
+ * project-specific identifier, date or version, and of credential-shaped example text — the `security`
+ * template must not trip the spec-007 secret scan it asks the reader to respect (asserted per template in
+ * `test/storage/builtin-directives.test.ts`).
+ *
+ * **Customization** (`dl-037-builtin-vs-custom-directive-precedence`, implemented by `task-055` in
+ * `selectDirectivesById`): a directive under `directives/custom/` with the same `id` wins over the
+ * built-in, and the shadow is reported as a warning. Built-ins themselves are non-removable
+ * (REQ-SEC-07, keyed on the `built-in/` directory).
+ *
+ * Pure data + a pure renderer (REQ-SYS-07): byte-identical output run to run.
+ */
+/** One built-in directive template, as structured data rendered by {@link builtinDirectiveMd}. */
+export interface BuiltinDirectiveTemplate {
+    /** Stable directive id — also the installed filename stem and the key `roles.yaml` binds on. */
+    readonly id: string;
+    /** Human-readable name; used as both `name` and `title` (spec-013 notes they coincide). */
+    readonly name: string;
+    /** One sentence naming who the directive applies to. */
+    readonly appliesTo: string;
+    /** The normative rules, in order, rendered as a Markdown bullet list. */
+    readonly rules: readonly string[];
+}
+/**
+ * The six P3.8 built-in directive templates, in the order the P3.8 feature lists them ("code-quality,
+ * testing, code-review, architecture, security, documentation"). Fixed order (REQ-SYS-07).
+ */
+export declare const BUILTIN_DIRECTIVE_TEMPLATES: readonly BuiltinDirectiveTemplate[];
+/** The built-in directive ids, in {@link BUILTIN_DIRECTIVE_TEMPLATES} order. */
+export declare const BUILTIN_DIRECTIVE_IDS: readonly string[];
+/**
+ * Render one built-in directive as the Markdown document installed at
+ * `.wingfoil/directives/built-in/<id>.md`: spec-013 frontmatter, then the rules, then a note on how to
+ * customize it. Pure — fixed strings only.
+ */
+export declare function builtinDirectiveMd(t: BuiltinDirectiveTemplate): string;
+//# sourceMappingURL=builtin-directives.d.ts.map

package/dist/storage/builtin-directives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-directives.d.ts","sourceRoot":"","sources":["../../src/storage/builtin-directives.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,kGAAkG;AAClG,MAAM,WAAW,wBAAwB;IACvC,gGAAgG;IAChG,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAoFD;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,wBAAwB,EAO1E,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAiD,CAAC;AAErG;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,wBAAwB,GAAG,MAAM,CAsBtE"}

package/dist/storage/builtin-directives.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * The official built-in directive templates (P3.8, US-0A-09 — `task-057-builtin-directive-templates`):
+ * Code Quality, Testing, Code Review, Architecture, Security, Documentation.
+ *
+ * **Where they live and how they reach a project.** `spec-011-storage-layout` reserves
+ * `.wingfoil/directives/built-in/` for "the official P3.8 directive templates shipped by the `wingfoil`
+ * npm package", and `spec-015-packaging-publishing` §1 keeps the tarball allowlist at
+ * `files: ["dist", "README.md"]` — so the templates ship as DATA compiled into `dist/`, not as loose
+ * Markdown beside it. `templateScaffold` (./templates) renders them into the `ScaffoldFile[]` that
+ * `wingfoil init` writes, which is also the list `initWingfoilProject` schema-checks first (REQ-SEC-10,
+ * derived by `builtinTemplateSources`): adding or editing a template here is automatically checked.
+ *
+ * **Frontmatter** (`spec-013-directive-frontmatter-schema`): exactly the declared keys `id` (the filename
+ * stem), `name`, `type: directive`, `kind: built-in`, `title`, `tags`, `ref: [P3.8]`. No other key: an
+ * undeclared key rides `.passthrough()` and prints an `unknown field(s) ignored` warning on stderr during
+ * every `init` (task-044's hand-off).
+ *
+ * **Body**: normative, project-agnostic rules for AI agents and humans. Deliberately free of any
+ * project-specific identifier, date or version, and of credential-shaped example text — the `security`
+ * template must not trip the spec-007 secret scan it asks the reader to respect (asserted per template in
+ * `test/storage/builtin-directives.test.ts`).
+ *
+ * **Customization** (`dl-037-builtin-vs-custom-directive-precedence`, implemented by `task-055` in
+ * `selectDirectivesById`): a directive under `directives/custom/` with the same `id` wins over the
+ * built-in, and the shadow is reported as a warning. Built-ins themselves are non-removable
+ * (REQ-SEC-07, keyed on the `built-in/` directory).
+ *
+ * Pure data + a pure renderer (REQ-SYS-07): byte-identical output run to run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_DIRECTIVE_IDS = exports.BUILTIN_DIRECTIVE_TEMPLATES = void 0;
+exports.builtinDirectiveMd = builtinDirectiveMd;
+const CODE_QUALITY = {
+    id: 'code-quality',
+    name: 'Code Quality',
+    appliesTo: 'Applies to every role that writes or changes code.',
+    rules: [
+        'The linter reports no errors; warnings are triaged before a change is merged.',
+        'Prefer small, single-responsibility functions and modules; keep complexity low.',
+        'No dead code and no commented-out blocks.',
+        'Match the style, naming and idioms of the surrounding code.',
+        'Give public interfaces explicit types and validate external input at system boundaries.',
+        'Keep each commit to one logical change with a descriptive message.',
+    ],
+};
+const TESTING = {
+    id: 'testing',
+    name: 'Testing',
+    appliesTo: 'Applies to developers and QA.',
+    rules: [
+        'Test first: write a failing test before the implementation (red, green, refactor).',
+        'Classify each acceptance criterion before testing it: red-first when the behaviour is new, characterization when the behaviour already exists and the test is expected to pass on its first run. Never fabricate a failing test or add dead code to force one.',
+        'Every behaviour has at least one happy-path test and one edge- or error-path test.',
+        'Keep coverage at or above the threshold the project declares; coverage must not regress.',
+        'Tests are deterministic and isolated: no reliance on external services, wall-clock time or randomness.',
+    ],
+};
+const CODE_REVIEW = {
+    id: 'code-review',
+    name: 'Code Review',
+    appliesTo: 'Applies to reviewers and to whoever holds approval authority.',
+    rules: [
+        'Check every change for correctness, tests that are present and passing, adherence to the other directives, and the absence of secrets.',
+        'Verify the change satisfies the acceptance criteria of the task it implements.',
+        'Verify claims by running the command that settles them; do not accept a statement about a file or test without checking it.',
+        'Every finding is either fixed in the change or recorded as a tracked element (a bug or a decision-log); never leave a finding only in review notes.',
+        'Approve or reject with a recorded reason; a rejection states what must change before resubmitting.',
+        'Approval authority belongs to a role, not to a person; AI agents never approve their own work.',
+    ],
+};
+const ARCHITECTURE = {
+    id: 'architecture',
+    name: 'Architecture',
+    appliesTo: 'Applies to architects and the tech lead.',
+    rules: [
+        'Record every significant architectural decision as an ADR stating its context, the decision and its consequences.',
+        'Every architectural decision references the requirement or requirements it implements.',
+        'Keep modules cohesive and loosely coupled; a change in one module must not force edits in unrelated ones.',
+        'Write a technical specification for every shared file format, schema, constant set or module API before the work that implements it starts.',
+        'Before approving a specification or an ADR, check that it is internally consistent, consistent with the already-approved specifications, aligned with the acceptance criteria, and traceable to its requirements.',
+    ],
+};
+const SECURITY = {
+    id: 'security',
+    name: 'Security',
+    appliesTo: 'Applies to every role.',
+    rules: [
+        'Never hardcode credentials, tokens, private keys or other secrets in source code, configuration, documentation or project memory.',
+        'Keep secrets out of version control; supply them at runtime from the environment or a secret manager.',
+        'When an example needs a credential, describe it in words or use an obvious placeholder; never paste a real value.',
+        'Validate and sanitize all external input at trust boundaries.',
+        'Grant the least privilege each component needs.',
+        'Review dependencies for known vulnerabilities before adding or upgrading them.',
+    ],
+};
+const DOCUMENTATION = {
+    id: 'documentation',
+    name: 'Documentation',
+    appliesTo: 'Applies to every role.',
+    rules: [
+        'Document every user-facing command and feature before it ships.',
+        'Update the affected documentation in the same change that alters behaviour.',
+        'Every public or exported API element carries a doc comment.',
+        'Record decisions in project memory (ADRs for architectural decisions, decision-logs for product and process decisions), not scattered through the codebase.',
+        'Keep cross-references between documents intact.',
+        'Document why, not only what.',
+    ],
+};
+/**
+ * The six P3.8 built-in directive templates, in the order the P3.8 feature lists them ("code-quality,
+ * testing, code-review, architecture, security, documentation"). Fixed order (REQ-SYS-07).
+ */
+exports.BUILTIN_DIRECTIVE_TEMPLATES = [
+    CODE_QUALITY,
+    TESTING,
+    CODE_REVIEW,
+    ARCHITECTURE,
+    SECURITY,
+    DOCUMENTATION,
+];
+/** The built-in directive ids, in {@link BUILTIN_DIRECTIVE_TEMPLATES} order. */
+exports.BUILTIN_DIRECTIVE_IDS = exports.BUILTIN_DIRECTIVE_TEMPLATES.map((t) => t.id);
+/**
+ * Render one built-in directive as the Markdown document installed at
+ * `.wingfoil/directives/built-in/<id>.md`: spec-013 frontmatter, then the rules, then a note on how to
+ * customize it. Pure — fixed strings only.
+ */
+function builtinDirectiveMd(t) {
+    const rules = t.rules.map((rule) => `- ${rule}`).join('\n');
+    return `---
+id: ${t.id}
+name: "${t.name}"
+type: directive
+kind: built-in
+title: "${t.name}"
+tags: [built-in, ${t.id}]
+ref: [P3.8]
+---
+
+# Directive — ${t.name}
+
+${t.appliesTo}
+
+${rules}
+
+> Built-in WingFoil directive template. It cannot be removed. To adapt it, create
+> \`directives/custom/${t.id}.md\` with \`id: ${t.id}\`: a custom directive with the same id takes
+> precedence over this one, and \`wingfoil directives list\` reports the override.
+`;
+}
+//# sourceMappingURL=builtin-directives.js.map

package/dist/storage/builtin-directives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-directives.js","sourceRoot":"","sources":["../../src/storage/builtin-directives.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;AAqHH,gDAsBC;AA7HD,MAAM,YAAY,GAA6B;IAC7C,EAAE,EAAE,cAAc;IAClB,IAAI,EAAE,cAAc;IACpB,SAAS,EAAE,oDAAoD;IAC/D,KAAK,EAAE;QACL,+EAA+E;QAC/E,iFAAiF;QACjF,2CAA2C;QAC3C,6DAA6D;QAC7D,yFAAyF;QACzF,oEAAoE;KACrE;CACF,CAAC;AAEF,MAAM,OAAO,GAA6B;IACxC,EAAE,EAAE,SAAS;IACb,IAAI,EAAE,SAAS;IACf,SAAS,EAAE,+BAA+B;IAC1C,KAAK,EAAE;QACL,oFAAoF;QACpF,gQAAgQ;QAChQ,oFAAoF;QACpF,0FAA0F;QAC1F,wGAAwG;KACzG;CACF,CAAC;AAEF,MAAM,WAAW,GAA6B;IAC5C,EAAE,EAAE,aAAa;IACjB,IAAI,EAAE,aAAa;IACnB,SAAS,EAAE,+DAA+D;IAC1E,KAAK,EAAE;QACL,wIAAwI;QACxI,gFAAgF;QAChF,6HAA6H;QAC7H,qJAAqJ;QACrJ,oGAAoG;QACpG,gGAAgG;KACjG;CACF,CAAC;AAEF,MAAM,YAAY,GAA6B;IAC7C,EAAE,EAAE,cAAc;IAClB,IAAI,EAAE,cAAc;IACpB,SAAS,EAAE,0CAA0C;IACrD,KAAK,EAAE;QACL,mHAAmH;QACnH,wFAAwF;QACxF,2GAA2G;QAC3G,6IAA6I;QAC7I,mNAAmN;KACpN;CACF,CAAC;AAEF,MAAM,QAAQ,GAA6B;IACzC,EAAE,EAAE,UAAU;IACd,IAAI,EAAE,UAAU;IAChB,SAAS,EAAE,wBAAwB;IACnC,KAAK,EAAE;QACL,mIAAmI;QACnI,uGAAuG;QACvG,mHAAmH;QACnH,+DAA+D;QAC/D,iDAAiD;QACjD,gFAAgF;KACjF;CACF,CAAC;AAEF,MAAM,aAAa,GAA6B;IAC9C,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,eAAe;IACrB,SAAS,EAAE,wBAAwB;IACnC,KAAK,EAAE;QACL,iEAAiE;QACjE,6EAA6E;QAC7E,6DAA6D;QAC7D,6JAA6J;QAC7J,iDAAiD;QACjD,8BAA8B;KAC/B;CACF,CAAC;AAEF;;;GAGG;AACU,QAAA,2BAA2B,GAAwC;IAC9E,YAAY;IACZ,OAAO;IACP,WAAW;IACX,YAAY;IACZ,QAAQ;IACR,aAAa;CACd,CAAC;AAEF,gFAAgF;AACnE,QAAA,qBAAqB,GAAsB,mCAA2B,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAErG;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,CAA2B;IAC5D,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5D,OAAO;MACH,CAAC,CAAC,EAAE;SACD,CAAC,CAAC,IAAI;;;UAGL,CAAC,CAAC,IAAI;mBACG,CAAC,CAAC,EAAE;;;;gBAIP,CAAC,CAAC,IAAI;;EAEpB,CAAC,CAAC,SAAS;;EAEX,KAAK;;;wBAGiB,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE;;CAEnD,CAAC;AACF,CAAC"}

package/dist/storage/commit.d.ts

@@ -0,0 +1,92 @@
+/** Options for {@link commitPaths} — carries the git-author/env override used by callers (e.g. task-029's wizard). */
+export interface CommitOptions {
+    /** Additional environment for the git invocations (merged over `process.env`). */
+    readonly env?: NodeJS.ProcessEnv;
+}
+/**
+ * Stage exactly `paths` (root-relative or absolute; each passed verbatim after `--` so a path that
+ * looks like a flag is never misread) and create a single commit with `message` that contains **only**
+ * those paths, returning the new commit's 40-hex sha. Other changes already staged in the index are
+ * neither committed nor unstaged (bug-027) — this also holds for the first commit of an empty
+ * repository (`wingfoil init`).
+ *
+ * Determinism note (REQ-SYS-07): a git commit's sha necessarily incorporates the author/commit
+ * timestamp, so two runs produce different shas — that is inherent to *creating* history and is not
+ * a context-building read path (the determinism rule targets read/derivation paths, e.g.
+ * `computeStateSnapshot`), so it is correct and intended here.
+ *
+ * @throws whatever `git` raises (via `execFileSync`) — e.g. nothing staged to commit, or `root` is
+ *   not a git repository. Callers that must translate those into a `CoreResult` do so at their layer
+ *   (see `src/core/init.ts`); this primitive stays a thin, throwing mechanism by design.
+ */
+export declare function commitPaths(root: string, paths: readonly string[], message: string, options?: CommitOptions): string;
+/**
+ * git's canonical empty tree object, the same on every repository (`git hash-object -t tree
+ * /dev/null`). Used as the parent of a **root** commit so "what changed between this commit and its
+ * parent" is total rather than conditional.
+ */
+export declare const EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+/**
+ * The content of `path` at revision `rev`, or `null` when the path does not exist there (git exits
+ * non-zero, which `execFileSync` raises).
+ *
+ * `rev` is any revision git accepts before a `:` — a sha, `HEAD`, or the index stage `:0`, which is
+ * how a caller reads what the user has **staged** as opposed to what is in the working tree. The two
+ * can disagree, and the difference is load-bearing: `git add` would silently replace a staged version
+ * with the working-tree one.
+ */
+export declare function readPathAtRev(root: string, rev: string, path: string, options?: CommitOptions): string | null;
+/**
+ * The two-character `git status --porcelain` code for `path` (index status, then working-tree
+ * status), or the empty string when the path is clean — unmodified in both, and tracked.
+ *
+ * Deliberately git's own answer rather than a content comparison: git owns what "modified" means
+ * here (index refresh, `core.autocrlf`, `.gitattributes` filters), and a caller that re-derived it
+ * from bytes would disagree with `git status` on exactly the machines where it matters.
+ */
+export declare function pathPorcelainStatus(root: string, path: string, options?: CommitOptions): string;
+/** The commit's parent sha, or {@link EMPTY_TREE_SHA} when it is a root commit. */
+export declare function commitParent(root: string, sha: string, options?: CommitOptions): string;
+/** Root-relative paths whose content differs between revisions `from` and `to`, in git's own order. */
+export declare function changedPathsBetween(root: string, from: string, to: string, options?: CommitOptions): string[];
+/**
+ * Every **file** that exists at revision `rev` under `prefix`, recursively, as root-relative POSIX
+ * paths sorted ascending — the directory counterpart of {@link readPathAtRev}, and the primitive a
+ * read whose baseline is a *directory* needs (`task-096`, `bug-086`).
+ *
+ * `readPathAtRev` answers "what does this one path contain at `<rev>`", which is enough while every
+ * committed-baseline read is of a file named in advance (`.wingfoil/dna.yaml`,
+ * `.wingfoil/memory.yaml`). It is not enough for `.wingfoil/directives/**`, whose members are
+ * discovered rather than named: without this, resolving the directive inventory at `HEAD` was
+ * impossible and `task-091` scoped `bug-086` out on exactly that ground. The two compose — list, then
+ * read each entry — and `src/core/loaders.ts`'s `loadDirectivesAtHead` is the first caller to do so.
+ *
+ * **Blobs only.** Whatever this returns must be readable with `readPathAtRev` at the same revision; a
+ * gitlink would break that, so it is filtered out rather than reported as a file.
+ *
+ * **`-z`, not the default output.** Without it git C-quotes a path containing a byte outside printable
+ * ASCII (`core.quotePath`, on by default), a control byte, a `"` or a `\`: it wraps the whole name in
+ * double quotes and escapes the offending bytes, so `caffè.md` is reported as `"caff\303\250.md"` and
+ * a caller then looks for a file whose name it has mis-spelled. A **space is not quoted** — worth
+ * naming because it makes `two words.md` a useless test of this property, and only a name git really
+ * quotes can hold the flag in place (`test/storage/list-paths-at-rev.test.ts`, "the `-z` pin"). With
+ * `-z` the records are NUL-separated and never quoted, whatever the bytes.
+ *
+ * **`null` is not `[]`.** `[]` means *the revision exists and holds nothing under `prefix`*; `null`
+ * means *`rev` does not resolve at all* — an unborn `HEAD` in a repository with no commits, or a name
+ * no object carries. A caller that must fail closed when there is no committed baseline has to be able
+ * to tell those apart; one that only wants "what is committed there" can write `?? []`.
+ *
+ * **Sorted explicitly** even though git's own output already is (REQ-SYS-07: no unordered iteration in
+ * a context-building path — the working-tree walk in `loadDirectives` sorts for the same reason, and
+ * the two must not differ by accident).
+ *
+ * @param root - Project root (the git repository).
+ * @param rev - Any tree-ish git accepts: a sha, `HEAD`, `HEAD~1`, a tag.
+ * @param prefix - Root-relative directory to limit the listing to; **omitted or empty lists the whole
+ *   tree**, because `git ls-tree -- ''` is an error rather than a match-all. Passed verbatim after
+ *   `--`, so a path that looks like a flag is never misread.
+ * @returns The paths, or `null` when `rev` does not resolve.
+ */
+export declare function listPathsAtRev(root: string, rev: string, prefix?: string, options?: CommitOptions): string[] | null;
+//# sourceMappingURL=commit.d.ts.map

package/dist/storage/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/storage/commit.ts"],"names":[],"mappings":"AAoBA,sHAAsH;AACtH,MAAM,WAAW,aAAa;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAClC;AA6BD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAOR;AASD;;;;GAIG;AACH,eAAO,MAAM,cAAc,6CAA6C,CAAC;AAEzE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,GAAG,IAAI,CAMjH;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAMnG;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAM3F;AAED,uGAAuG;AACvG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,EAAE,CAIjH;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,SAAK,EACX,OAAO,GAAE,aAAkB,GAC1B,MAAM,EAAE,GAAG,IAAI,CAejB"}

package/dist/storage/commit.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_TREE_SHA = void 0;
+exports.commitPaths = commitPaths;
+exports.readPathAtRev = readPathAtRev;
+exports.pathPorcelainStatus = pathPorcelainStatus;
+exports.commitParent = commitParent;
+exports.changedPathsBetween = changedPathsBetween;
+exports.listPathsAtRev = listPathsAtRev;
+/**
+ * The reusable git-commit primitive (task-018-implement-git-backed-storage, P1.1, REQ-SYS-01).
+ *
+ * `writeDocument` (./document) writes bytes only; nothing else in `src/storage` turns a set of
+ * writes into a commit, yet every mutating core operation must return a `CoreResult.commit`
+ * `{sha, message}` (src/core/types). This is that missing producer: it stages **only** the scoped
+ * paths it is handed — never `git add -A`/`git add .`, which would sweep in unrelated working-tree
+ * changes (and, in a WingFoil worktree, the `node_modules` symlink) — and produces **exactly one**
+ * commit, returning its full sha. Every mutating Wave-3 task (task-019 versioning, task-020 memory
+ * add, task-025 dna set, task-029 `wingfoil init`) turns its writes into a single attributable
+ * commit through this one helper, so the "one operation = one scoped commit" convention
+ * (CLAUDE.md §5.1) has a single implementation rather than being re-derived per task.
+ *
+ * Mirrors the git-primitive style in `src/memory/git-log.ts`: `execFileSync('git', …)` (never a
+ * shell), `-C <root>` to target the repository, and `env: process.env` passed **explicitly** — the
+ * latter matters under Jest, whose worker env is not the ambient shell's, so relying on the default
+ * env silently drops `GIT_*` overrides a test sets (the task-014 env-isolation gotcha).
+ */
+const child_process_1 = require("child_process");
+function runGit(root, args, options) {
+    return (0, child_process_1.execFileSync)('git', ['-C', root, ...args], {
+        encoding: 'utf-8',
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+    });
+}
+/**
+ * {@link runGit} for a **probe** — an invocation whose failure is an expected answer rather than an
+ * error, or whose stderr is noise the caller must not surface, so git's own diagnostic does not reach
+ * the caller's stderr. Without `stdio[2]: 'ignore'`, `execFileSync` inherits fd 2 and
+ * `git show HEAD:<untracked>` prints `fatal: path … exists on disk, but not in 'HEAD'` into the
+ * user's terminal alongside the message the CLI actually meant to emit.
+ *
+ * The second case arrived with task-092: `git status --porcelain -- <path>` exits **0** but prints
+ * `warning: could not open directory '<dir>/': No such file or directory` when an intermediate
+ * directory of the pathspec is absent — the ordinary case for a write guard asking about a file that
+ * has not been created yet. A non-zero exit still raises through `execFileSync` exactly as before.
+ */
+function probeGit(root, args, options) {
+    return (0, child_process_1.execFileSync)('git', ['-C', root, ...args], {
+        encoding: 'utf-8',
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+}
+/**
+ * Stage exactly `paths` (root-relative or absolute; each passed verbatim after `--` so a path that
+ * looks like a flag is never misread) and create a single commit with `message` that contains **only**
+ * those paths, returning the new commit's 40-hex sha. Other changes already staged in the index are
+ * neither committed nor unstaged (bug-027) — this also holds for the first commit of an empty
+ * repository (`wingfoil init`).
+ *
+ * Determinism note (REQ-SYS-07): a git commit's sha necessarily incorporates the author/commit
+ * timestamp, so two runs produce different shas — that is inherent to *creating* history and is not
+ * a context-building read path (the determinism rule targets read/derivation paths, e.g.
+ * `computeStateSnapshot`), so it is correct and intended here.
+ *
+ * @throws whatever `git` raises (via `execFileSync`) — e.g. nothing staged to commit, or `root` is
+ *   not a git repository. Callers that must translate those into a `CoreResult` do so at their layer
+ *   (see `src/core/init.ts`); this primitive stays a thin, throwing mechanism by design.
+ */
+function commitPaths(root, paths, message, options = {}) {
+    runGit(root, ['add', '--', ...paths], options);
+    // `--only -- <paths>` records exactly these paths, whatever else is staged: anything a caller or
+    // another tool already staged stays staged and uncommitted (bug-027). A plain `git commit` would
+    // commit the whole index under a subject that names only this operation.
+    runGit(root, ['commit', '--only', '--quiet', '-m', message, '--', ...paths], options);
+    return runGit(root, ['rev-parse', 'HEAD'], options).trim();
+}
+// --- Read primitives for asserting what a commit CONTAINS (task-088, bug-076) ------------------
+//
+// `commitPaths` above bounds a commit by *pathspec*; nothing bounded it by *content*, so a path that
+// was already modified on disk rode into a commit whose subject declared only a state change. The
+// three readers below are what lets a caller assert the diff a commit actually carries, instead of
+// re-reading the file on disk and finding — truthfully, and uselessly — that it says what it should.
+/**
+ * git's canonical empty tree object, the same on every repository (`git hash-object -t tree
+ * /dev/null`). Used as the parent of a **root** commit so "what changed between this commit and its
+ * parent" is total rather than conditional.
+ */
+exports.EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+/**
+ * The content of `path` at revision `rev`, or `null` when the path does not exist there (git exits
+ * non-zero, which `execFileSync` raises).
+ *
+ * `rev` is any revision git accepts before a `:` — a sha, `HEAD`, or the index stage `:0`, which is
+ * how a caller reads what the user has **staged** as opposed to what is in the working tree. The two
+ * can disagree, and the difference is load-bearing: `git add` would silently replace a staged version
+ * with the working-tree one.
+ */
+function readPathAtRev(root, rev, path, options = {}) {
+    try {
+        return probeGit(root, ['show', `${rev}:${path}`], options);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The two-character `git status --porcelain` code for `path` (index status, then working-tree
+ * status), or the empty string when the path is clean — unmodified in both, and tracked.
+ *
+ * Deliberately git's own answer rather than a content comparison: git owns what "modified" means
+ * here (index refresh, `core.autocrlf`, `.gitattributes` filters), and a caller that re-derived it
+ * from bytes would disagree with `git status` on exactly the machines where it matters.
+ */
+function pathPorcelainStatus(root, path, options = {}) {
+    // `probeGit`, not `runGit`: git writes a `warning: could not open directory …` to stderr — while
+    // still exiting 0 and answering correctly — whenever an intermediate directory of the pathspec is
+    // absent, which is routine for a guard asking about a file that does not exist yet (task-092).
+    const line = probeGit(root, ['status', '--porcelain', '--', path], options).split('\n')[0] ?? '';
+    return line.length === 0 ? '' : line.slice(0, 2);
+}
+/** The commit's parent sha, or {@link EMPTY_TREE_SHA} when it is a root commit. */
+function commitParent(root, sha, options = {}) {
+    try {
+        return probeGit(root, ['rev-parse', '--verify', '--quiet', `${sha}^`], options).trim();
+    }
+    catch {
+        return exports.EMPTY_TREE_SHA;
+    }
+}
+/** Root-relative paths whose content differs between revisions `from` and `to`, in git's own order. */
+function changedPathsBetween(root, from, to, options = {}) {
+    return runGit(root, ['diff', '--name-only', from, to], options)
+        .split('\n')
+        .filter((path) => path.length > 0);
+}
+// --- Listing a DIRECTORY at a revision (task-096, bug-086) -------------------------------------
+/**
+ * One `git ls-tree -z` record: `<mode> SP <type> SP <object> TAB <path>`. Matched rather than split
+ * so that (a) only **blobs** survive — a gitlink (submodule, mode `160000`) is an entry in the tree
+ * but not a file anyone can read back — and (b) the path is taken verbatim from the first TAB
+ * onwards, which is the one separator a path cannot contain.
+ */
+const LS_TREE_BLOB_RECORD = /^\d+ blob [0-9a-f]+\t/;
+/**
+ * Every **file** that exists at revision `rev` under `prefix`, recursively, as root-relative POSIX
+ * paths sorted ascending — the directory counterpart of {@link readPathAtRev}, and the primitive a
+ * read whose baseline is a *directory* needs (`task-096`, `bug-086`).
+ *
+ * `readPathAtRev` answers "what does this one path contain at `<rev>`", which is enough while every
+ * committed-baseline read is of a file named in advance (`.wingfoil/dna.yaml`,
+ * `.wingfoil/memory.yaml`). It is not enough for `.wingfoil/directives/**`, whose members are
+ * discovered rather than named: without this, resolving the directive inventory at `HEAD` was
+ * impossible and `task-091` scoped `bug-086` out on exactly that ground. The two compose — list, then
+ * read each entry — and `src/core/loaders.ts`'s `loadDirectivesAtHead` is the first caller to do so.
+ *
+ * **Blobs only.** Whatever this returns must be readable with `readPathAtRev` at the same revision; a
+ * gitlink would break that, so it is filtered out rather than reported as a file.
+ *
+ * **`-z`, not the default output.** Without it git C-quotes a path containing a byte outside printable
+ * ASCII (`core.quotePath`, on by default), a control byte, a `"` or a `\`: it wraps the whole name in
+ * double quotes and escapes the offending bytes, so `caffè.md` is reported as `"caff\303\250.md"` and
+ * a caller then looks for a file whose name it has mis-spelled. A **space is not quoted** — worth
+ * naming because it makes `two words.md` a useless test of this property, and only a name git really
+ * quotes can hold the flag in place (`test/storage/list-paths-at-rev.test.ts`, "the `-z` pin"). With
+ * `-z` the records are NUL-separated and never quoted, whatever the bytes.
+ *
+ * **`null` is not `[]`.** `[]` means *the revision exists and holds nothing under `prefix`*; `null`
+ * means *`rev` does not resolve at all* — an unborn `HEAD` in a repository with no commits, or a name
+ * no object carries. A caller that must fail closed when there is no committed baseline has to be able
+ * to tell those apart; one that only wants "what is committed there" can write `?? []`.
+ *
+ * **Sorted explicitly** even though git's own output already is (REQ-SYS-07: no unordered iteration in
+ * a context-building path — the working-tree walk in `loadDirectives` sorts for the same reason, and
+ * the two must not differ by accident).
+ *
+ * @param root - Project root (the git repository).
+ * @param rev - Any tree-ish git accepts: a sha, `HEAD`, `HEAD~1`, a tag.
+ * @param prefix - Root-relative directory to limit the listing to; **omitted or empty lists the whole
+ *   tree**, because `git ls-tree -- ''` is an error rather than a match-all. Passed verbatim after
+ *   `--`, so a path that looks like a flag is never misread.
+ * @returns The paths, or `null` when `rev` does not resolve.
+ */
+function listPathsAtRev(root, rev, prefix = '', options = {}) {
+    const pathspec = prefix.length === 0 ? [] : ['--', prefix];
+    let records;
+    try {
+        // `probeGit`: an unresolvable revision is an expected answer here, and git's `fatal: Not a valid
+        // object name` must not reach the user's terminal beside the CLI's own message.
+        records = probeGit(root, ['ls-tree', '-r', '-z', '--full-tree', rev, ...pathspec], options);
+    }
+    catch {
+        return null;
+    }
+    return records
+        .split('\0')
+        .filter((record) => LS_TREE_BLOB_RECORD.test(record))
+        .map((record) => record.slice(record.indexOf('\t') + 1))
+        .sort();
+}
+//# sourceMappingURL=commit.js.map

package/dist/storage/commit.js.map

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