wingfoil 0.2.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAG,SAAkB,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChG,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACnE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9I,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACzF,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EACL,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,EAAE,2BAA2B,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC9G,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACrE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/storage/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeSnapshot = exports.computeStateSnapshot = exports.builtinDirectiveMd = exports.BUILTIN_DIRECTIVE_IDS = exports.BUILTIN_DIRECTIVE_TEMPLATES = exports.BUILTIN_WORKFLOWS_DIR = exports.BUILTIN_DIRECTIVES_DIR = exports.builtinTemplateSources = exports.initProjectCommitMessage = exports.templateScaffold = exports.resolveTemplate = exports.DEFAULT_TEMPLATE = exports.TEMPLATE_NAMES = exports.TEMPLATES = exports.INIT_COMMIT_MESSAGE = exports.WINGFOIL_DIR = exports.scaffoldFiles = exports.initStorage = exports.readPathAtRev = exports.pathPorcelainStatus = exports.listPathsAtRev = exports.EMPTY_TREE_SHA = exports.commitPaths = exports.commitParent = exports.changedPathsBetween = exports.writeDocument = exports.removeDocument = exports.documentExists = exports.readDocument = exports.splitFrontmatter = exports.extractFrontmatter = exports.resolveRealPathInRoot = exports.escapesRoot = exports.resolveMemoryPath = exports.renderMemoryPath = exports.detectInitState = exports.resolveProjectRoot = exports.findGitRoot = exports.E_MISSING_PATH_VALUE = exports.E_NOT_AT_GIT_ROOT = exports.E_NO_GIT_ROOT = exports.StorageError = exports.MODULE_NAME = void 0;
+/**
+ * `storage` module — git-backed file storage (YAML + Markdown); single source of truth
+ * (REQ-SYS-01, task-003-git-backed-sot). Single entry point for: resolving the WingFoil project
+ * root, detecting initialization state, rendering a Memory type's `path` pattern
+ * (spec-001-memory-yaml-schema) against concrete values, reading/writing document bytes, and
+ * computing the whole-project state snapshot the REQ-SYS-01 fit criterion is stated in terms of.
+ */
+exports.MODULE_NAME = 'storage';
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "StorageError", { enumerable: true, get: function () { return errors_1.StorageError; } });
+Object.defineProperty(exports, "E_NO_GIT_ROOT", { enumerable: true, get: function () { return errors_1.E_NO_GIT_ROOT; } });
+Object.defineProperty(exports, "E_NOT_AT_GIT_ROOT", { enumerable: true, get: function () { return errors_1.E_NOT_AT_GIT_ROOT; } });
+Object.defineProperty(exports, "E_MISSING_PATH_VALUE", { enumerable: true, get: function () { return errors_1.E_MISSING_PATH_VALUE; } });
+var git_root_1 = require("./git-root");
+Object.defineProperty(exports, "findGitRoot", { enumerable: true, get: function () { return git_root_1.findGitRoot; } });
+Object.defineProperty(exports, "resolveProjectRoot", { enumerable: true, get: function () { return git_root_1.resolveProjectRoot; } });
+var init_state_1 = require("./init-state");
+Object.defineProperty(exports, "detectInitState", { enumerable: true, get: function () { return init_state_1.detectInitState; } });
+var memory_path_1 = require("./memory-path");
+Object.defineProperty(exports, "renderMemoryPath", { enumerable: true, get: function () { return memory_path_1.renderMemoryPath; } });
+Object.defineProperty(exports, "resolveMemoryPath", { enumerable: true, get: function () { return memory_path_1.resolveMemoryPath; } });
+var confinement_1 = require("./confinement");
+Object.defineProperty(exports, "escapesRoot", { enumerable: true, get: function () { return confinement_1.escapesRoot; } });
+Object.defineProperty(exports, "resolveRealPathInRoot", { enumerable: true, get: function () { return confinement_1.resolveRealPathInRoot; } });
+var frontmatter_1 = require("./frontmatter");
+Object.defineProperty(exports, "extractFrontmatter", { enumerable: true, get: function () { return frontmatter_1.extractFrontmatter; } });
+Object.defineProperty(exports, "splitFrontmatter", { enumerable: true, get: function () { return frontmatter_1.splitFrontmatter; } });
+var document_1 = require("./document");
+Object.defineProperty(exports, "readDocument", { enumerable: true, get: function () { return document_1.readDocument; } });
+Object.defineProperty(exports, "documentExists", { enumerable: true, get: function () { return document_1.documentExists; } });
+Object.defineProperty(exports, "removeDocument", { enumerable: true, get: function () { return document_1.removeDocument; } });
+Object.defineProperty(exports, "writeDocument", { enumerable: true, get: function () { return document_1.writeDocument; } });
+var commit_1 = require("./commit");
+Object.defineProperty(exports, "changedPathsBetween", { enumerable: true, get: function () { return commit_1.changedPathsBetween; } });
+Object.defineProperty(exports, "commitParent", { enumerable: true, get: function () { return commit_1.commitParent; } });
+Object.defineProperty(exports, "commitPaths", { enumerable: true, get: function () { return commit_1.commitPaths; } });
+Object.defineProperty(exports, "EMPTY_TREE_SHA", { enumerable: true, get: function () { return commit_1.EMPTY_TREE_SHA; } });
+Object.defineProperty(exports, "listPathsAtRev", { enumerable: true, get: function () { return commit_1.listPathsAtRev; } });
+Object.defineProperty(exports, "pathPorcelainStatus", { enumerable: true, get: function () { return commit_1.pathPorcelainStatus; } });
+Object.defineProperty(exports, "readPathAtRev", { enumerable: true, get: function () { return commit_1.readPathAtRev; } });
+var layout_1 = require("./layout");
+Object.defineProperty(exports, "initStorage", { enumerable: true, get: function () { return layout_1.initStorage; } });
+Object.defineProperty(exports, "scaffoldFiles", { enumerable: true, get: function () { return layout_1.scaffoldFiles; } });
+Object.defineProperty(exports, "WINGFOIL_DIR", { enumerable: true, get: function () { return layout_1.WINGFOIL_DIR; } });
+Object.defineProperty(exports, "INIT_COMMIT_MESSAGE", { enumerable: true, get: function () { return layout_1.INIT_COMMIT_MESSAGE; } });
+var templates_1 = require("./templates");
+Object.defineProperty(exports, "TEMPLATES", { enumerable: true, get: function () { return templates_1.TEMPLATES; } });
+Object.defineProperty(exports, "TEMPLATE_NAMES", { enumerable: true, get: function () { return templates_1.TEMPLATE_NAMES; } });
+Object.defineProperty(exports, "DEFAULT_TEMPLATE", { enumerable: true, get: function () { return templates_1.DEFAULT_TEMPLATE; } });
+Object.defineProperty(exports, "resolveTemplate", { enumerable: true, get: function () { return templates_1.resolveTemplate; } });
+Object.defineProperty(exports, "templateScaffold", { enumerable: true, get: function () { return templates_1.templateScaffold; } });
+Object.defineProperty(exports, "initProjectCommitMessage", { enumerable: true, get: function () { return templates_1.initProjectCommitMessage; } });
+Object.defineProperty(exports, "builtinTemplateSources", { enumerable: true, get: function () { return templates_1.builtinTemplateSources; } });
+Object.defineProperty(exports, "BUILTIN_DIRECTIVES_DIR", { enumerable: true, get: function () { return templates_1.BUILTIN_DIRECTIVES_DIR; } });
+Object.defineProperty(exports, "BUILTIN_WORKFLOWS_DIR", { enumerable: true, get: function () { return templates_1.BUILTIN_WORKFLOWS_DIR; } });
+var builtin_directives_1 = require("./builtin-directives");
+Object.defineProperty(exports, "BUILTIN_DIRECTIVE_TEMPLATES", { enumerable: true, get: function () { return builtin_directives_1.BUILTIN_DIRECTIVE_TEMPLATES; } });
+Object.defineProperty(exports, "BUILTIN_DIRECTIVE_IDS", { enumerable: true, get: function () { return builtin_directives_1.BUILTIN_DIRECTIVE_IDS; } });
+Object.defineProperty(exports, "builtinDirectiveMd", { enumerable: true, get: function () { return builtin_directives_1.builtinDirectiveMd; } });
+var snapshot_1 = require("./snapshot");
+Object.defineProperty(exports, "computeStateSnapshot", { enumerable: true, get: function () { return snapshot_1.computeStateSnapshot; } });
+Object.defineProperty(exports, "serializeSnapshot", { enumerable: true, get: function () { return snapshot_1.serializeSnapshot; } });
+//# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACU,QAAA,WAAW,GAAG,SAAkB,CAAC;AAE9C,mCAAgG;AAAvF,sGAAA,YAAY,OAAA;AAAE,uGAAA,aAAa,OAAA;AAAE,2GAAA,iBAAiB,OAAA;AAAE,8GAAA,oBAAoB,OAAA;AAC7E,uCAA6D;AAApD,uGAAA,WAAW,OAAA;AAAE,8GAAA,kBAAkB,OAAA;AACxC,2CAA+C;AAAtC,6GAAA,eAAe,OAAA;AAExB,6CAAoE;AAA3D,+GAAA,gBAAgB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAC5C,6CAAmE;AAA1D,0GAAA,WAAW,OAAA;AAAE,oHAAA,qBAAqB,OAAA;AAE3C,6CAAqE;AAA5D,iHAAA,kBAAkB,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AAE7C,uCAAyF;AAAhF,wGAAA,YAAY,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,yGAAA,aAAa,OAAA;AACpE,mCAA8I;AAArI,6GAAA,mBAAmB,OAAA;AAAE,sGAAA,YAAY,OAAA;AAAE,qGAAA,WAAW,OAAA;AAAE,wGAAA,cAAc,OAAA;AAAE,wGAAA,cAAc,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAAE,uGAAA,aAAa,OAAA;AAE3H,mCAAyF;AAAhF,qGAAA,WAAW,OAAA;AAAE,uGAAA,aAAa,OAAA;AAAE,sGAAA,YAAY,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAEtE,yCAUqB;AATnB,sGAAA,SAAS,OAAA;AACT,2GAAA,cAAc,OAAA;AACd,6GAAA,gBAAgB,OAAA;AAChB,4GAAA,eAAe,OAAA;AACf,6GAAA,gBAAgB,OAAA;AAChB,qHAAA,wBAAwB,OAAA;AACxB,mHAAA,sBAAsB,OAAA;AACtB,mHAAA,sBAAsB,OAAA;AACtB,kHAAA,qBAAqB,OAAA;AAGvB,2DAA8G;AAArG,iIAAA,2BAA2B,OAAA;AAAE,2HAAA,qBAAqB,OAAA;AAAE,wHAAA,kBAAkB,OAAA;AAE/E,uCAAqE;AAA5D,gHAAA,oBAAoB,OAAA;AAAE,6GAAA,iBAAiB,OAAA"}

package/dist/storage/init-state.d.ts

@@ -0,0 +1,9 @@
+/** The three states a project can be in relative to WingFoil initialization (spec-011). */
+export type InitState = 'absent' | 'incomplete' | 'initialized';
+/**
+ * Detect whether `root` (a resolved project root — see {@link resolveProjectRoot} in
+ * `./git-root`) is already WingFoil-initialized: `.wingfoil/` must exist AND contain at least one
+ * entry. No other marker file is consulted.
+ */
+export declare function detectInitState(root: string): InitState;
+//# sourceMappingURL=init-state.d.ts.map

package/dist/storage/init-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-state.d.ts","sourceRoot":"","sources":["../../src/storage/init-state.ts"],"names":[],"mappings":"AASA,2FAA2F;AAC3F,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,aAAa,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAKvD"}

package/dist/storage/init-state.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectInitState = detectInitState;
+/**
+ * Initialization-marker detection (task-003-git-backed-sot, REQ-SYS-01, spec-011-storage-layout
+ * "Initialization-marker detection algorithm"). Intentionally shallow — top-level non-emptiness
+ * only; deep validation of individual pillar files is each pillar's own schema-load responsibility
+ * (REQ-SYS-02), not this check's job.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detect whether `root` (a resolved project root — see {@link resolveProjectRoot} in
+ * `./git-root`) is already WingFoil-initialized: `.wingfoil/` must exist AND contain at least one
+ * entry. No other marker file is consulted.
+ */
+function detectInitState(root) {
+    const wingfoilDir = (0, path_1.join)(root, '.wingfoil');
+    if (!(0, fs_1.existsSync)(wingfoilDir))
+        return 'absent';
+    const entries = (0, fs_1.readdirSync)(wingfoilDir);
+    return entries.length > 0 ? 'initialized' : 'incomplete';
+}
+//# sourceMappingURL=init-state.js.map

package/dist/storage/init-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-state.js","sourceRoot":"","sources":["../../src/storage/init-state.ts"],"names":[],"mappings":";;AAiBA,0CAKC;AAtBD;;;;;GAKG;AACH,2BAA6C;AAC7C,+BAA4B;AAK5B;;;;GAIG;AACH,SAAgB,eAAe,CAAC,IAAY;IAC1C,MAAM,WAAW,GAAG,IAAA,WAAI,EAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAC5C,IAAI,CAAC,IAAA,eAAU,EAAC,WAAW,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC9C,MAAM,OAAO,GAAG,IAAA,gBAAW,EAAC,WAAW,CAAC,CAAC;IACzC,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC;AAC3D,CAAC"}

package/dist/storage/layout.d.ts

@@ -0,0 +1,51 @@
+/** The WingFoil root directory name, relative to the project (git) root (spec-011-storage-layout). */
+export declare const WINGFOIL_DIR = ".wingfoil";
+/** Default git subject for the one commit `initStorage` produces (overridable via `initStorage`). */
+export declare const INIT_COMMIT_MESSAGE = "chore(wingfoil): initialize .wingfoil/ storage (P1.1)";
+/** One file to scaffold: a root-relative (POSIX) path under `.wingfoil/` and its initial content. */
+export interface ScaffoldFile {
+    /** Path relative to the project root, always under `.wingfoil/`, POSIX-separated. */
+    readonly path: string;
+    /** Initial file content written verbatim (bytes-only — see {@link writeDocument}). */
+    readonly content: string;
+}
+/**
+ * The default `.wingfoil/` skeleton: exactly the files the P1.1 acceptance contract
+ * (P1.1-git-backed-storage.feature scenario 1) and the P3.5 directive-layout contract
+ * (p3-directives/P3.5-project-directives.feature scenario 1) require, in a fixed, hand-written order.
+ * Pure and deterministic — no wall-clock, no environment read — so repeated calls are byte-identical
+ * (REQ-SYS-07) and callers may compare/diff the set safely.
+ *
+ * That order is stable but is NOT a lexical sort, which is worth stating because the literal below
+ * reads like one: `'.'` (0x2E) sorts before `'/'` (0x2F), so sorting these paths would put
+ * `.wingfoil/memory.yaml` BEFORE `.wingfoil/memory/.gitkeep` — the reverse of the order written here.
+ * Determinism never depended on the list being sorted, only on it being fixed, which a literal is; so
+ * this is a property callers must not assume, not a defect to "fix" by sorting. Contrast
+ * `templateScaffold` (./templates), which genuinely does sort its output.
+ *
+ * `directives/` is split into `built-in/` and `custom/` per spec-011-storage-layout, each reserved by
+ * its own `.gitkeep`: P3.5 requires BOTH subfolders to be tracked by git, and git tracks files rather
+ * than directories, so one placeholder per subfolder is the minimum that discharges it
+ * (task-054-project-directives).
+ *
+ * That split is also why `initWingfoilStorage` (`src/core/init.ts`) runs the REQ-SEC-10 built-in
+ * integrity guard over this list before writing it: `directives/built-in/` is a built-in ASSET
+ * directory, so anything non-dotfile ever added here must be schema-checked first. Adding such a file
+ * needs no edit there — `builtinTemplateSources` derives the checked set from whatever this function
+ * returns (bug-018-init-storage-bypasses-integrity-guard).
+ *
+ * `workflows/{built-in,custom}/` is deliberately NOT part of this skeleton: it is P4.17 ground, and
+ * the complete spec-011 layout is `templateScaffold`'s job (see ./templates).
+ */
+export declare function scaffoldFiles(): ScaffoldFile[];
+/**
+ * Write every file in `files` (default: {@link scaffoldFiles}) under `root` and stage exactly those
+ * paths as a **single** commit (via {@link commitPaths}), returning the new commit's sha.
+ *
+ * Pure mechanism: it assumes `root` is already a validated git root (the "not a git repository" guard
+ * and the git-identity pre-flight live in the `CoreResult` wrapper, `src/core/init.ts`, so both the
+ * CLI and MCP surfaces enforce them identically — REQ-SYS-05). Only the given paths are staged, never
+ * `git add -A`, so no unrelated working-tree change is swept into the init commit.
+ */
+export declare function initStorage(root: string, files?: readonly ScaffoldFile[], message?: string): string;
+//# sourceMappingURL=layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/storage/layout.ts"],"names":[],"mappings":"AAkBA,sGAAsG;AACtG,eAAO,MAAM,YAAY,cAAc,CAAC;AAExC,qGAAqG;AACrG,eAAO,MAAM,mBAAmB,0DAA0D,CAAC;AAE3F,qGAAqG;AACrG,MAAM,WAAW,YAAY;IAC3B,qFAAqF;IACrF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,IAAI,YAAY,EAAE,CAS9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,SAAS,YAAY,EAAoB,EAChD,OAAO,GAAE,MAA4B,GACpC,MAAM,CAKR"}

package/dist/storage/layout.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INIT_COMMIT_MESSAGE = exports.WINGFOIL_DIR = void 0;
+exports.scaffoldFiles = scaffoldFiles;
+exports.initStorage = initStorage;
+/**
+ * `.wingfoil/` layout scaffolding + init routine (task-018-implement-git-backed-storage, P1.1,
+ * REQ-SYS-01 git-backed single source of truth, REQ-SYS-02 decoupled pillars; spec-011-storage-layout).
+ *
+ * This owns the *mechanism* of laying down and committing the `.wingfoil/` skeleton — the reusable
+ * substrate `wingfoil init` (task-029) builds its interactive wizard on top of. It deliberately does
+ * NOT implement the CLI command, prompt for values, or populate the full spec-011 layout with real
+ * pillar content: `scaffoldFiles()` returns only the minimal committed skeleton the P1.1 acceptance
+ * contract requires (`dna.yaml`/`memory.yaml`/`workflows.yaml` + the `memory/` and
+ * `directives/{built-in,custom}/` subfolders), and `initStorage` takes an optional `files` override so
+ * task-029's wizard can pass its own richer, spec-011-complete file set (with real content) through
+ * the exact same write+commit path.
+ */
+const path_1 = require("path");
+const commit_1 = require("./commit");
+const document_1 = require("./document");
+/** The WingFoil root directory name, relative to the project (git) root (spec-011-storage-layout). */
+exports.WINGFOIL_DIR = '.wingfoil';
+/** Default git subject for the one commit `initStorage` produces (overridable via `initStorage`). */
+exports.INIT_COMMIT_MESSAGE = 'chore(wingfoil): initialize .wingfoil/ storage (P1.1)';
+// Placeholder pillar-config stubs. Minimal, valid-YAML skeletons only — the real DNA/Memory/Workflow
+// schemas are populated by their owning tasks / task-029's wizard, not by this foundational layout.
+const DNA_STUB = 'version: 1\n# Project DNA (P2.4) — populated by `wingfoil init` / task-025.\n';
+const MEMORY_STUB = 'version: 1\ntypes: {}\n# Memory registry (P1.13) — populated by task-029.\n';
+const WORKFLOWS_STUB = 'version: 1\nincludes: []\n# Workflow config (P4.1) — populated by task-029.\n';
+// Git does not track empty directories, so each required subfolder carries a `.gitkeep` placeholder;
+// this makes `memory/` and `directives/{built-in,custom}/` real, committed, git-tracked directories
+// (P1.1 scenario 1; P3.5 scenario 1's "And both are tracked by git" — see `scaffoldFiles`).
+const GITKEEP = '';
+/**
+ * The default `.wingfoil/` skeleton: exactly the files the P1.1 acceptance contract
+ * (P1.1-git-backed-storage.feature scenario 1) and the P3.5 directive-layout contract
+ * (p3-directives/P3.5-project-directives.feature scenario 1) require, in a fixed, hand-written order.
+ * Pure and deterministic — no wall-clock, no environment read — so repeated calls are byte-identical
+ * (REQ-SYS-07) and callers may compare/diff the set safely.
+ *
+ * That order is stable but is NOT a lexical sort, which is worth stating because the literal below
+ * reads like one: `'.'` (0x2E) sorts before `'/'` (0x2F), so sorting these paths would put
+ * `.wingfoil/memory.yaml` BEFORE `.wingfoil/memory/.gitkeep` — the reverse of the order written here.
+ * Determinism never depended on the list being sorted, only on it being fixed, which a literal is; so
+ * this is a property callers must not assume, not a defect to "fix" by sorting. Contrast
+ * `templateScaffold` (./templates), which genuinely does sort its output.
+ *
+ * `directives/` is split into `built-in/` and `custom/` per spec-011-storage-layout, each reserved by
+ * its own `.gitkeep`: P3.5 requires BOTH subfolders to be tracked by git, and git tracks files rather
+ * than directories, so one placeholder per subfolder is the minimum that discharges it
+ * (task-054-project-directives).
+ *
+ * That split is also why `initWingfoilStorage` (`src/core/init.ts`) runs the REQ-SEC-10 built-in
+ * integrity guard over this list before writing it: `directives/built-in/` is a built-in ASSET
+ * directory, so anything non-dotfile ever added here must be schema-checked first. Adding such a file
+ * needs no edit there — `builtinTemplateSources` derives the checked set from whatever this function
+ * returns (bug-018-init-storage-bypasses-integrity-guard).
+ *
+ * `workflows/{built-in,custom}/` is deliberately NOT part of this skeleton: it is P4.17 ground, and
+ * the complete spec-011 layout is `templateScaffold`'s job (see ./templates).
+ */
+function scaffoldFiles() {
+    return [
+        { path: `${exports.WINGFOIL_DIR}/directives/built-in/.gitkeep`, content: GITKEEP },
+        { path: `${exports.WINGFOIL_DIR}/directives/custom/.gitkeep`, content: GITKEEP },
+        { path: `${exports.WINGFOIL_DIR}/dna.yaml`, content: DNA_STUB },
+        { path: `${exports.WINGFOIL_DIR}/memory/.gitkeep`, content: GITKEEP },
+        { path: `${exports.WINGFOIL_DIR}/memory.yaml`, content: MEMORY_STUB },
+        { path: `${exports.WINGFOIL_DIR}/workflows.yaml`, content: WORKFLOWS_STUB },
+    ];
+}
+/**
+ * Write every file in `files` (default: {@link scaffoldFiles}) under `root` and stage exactly those
+ * paths as a **single** commit (via {@link commitPaths}), returning the new commit's sha.
+ *
+ * Pure mechanism: it assumes `root` is already a validated git root (the "not a git repository" guard
+ * and the git-identity pre-flight live in the `CoreResult` wrapper, `src/core/init.ts`, so both the
+ * CLI and MCP surfaces enforce them identically — REQ-SYS-05). Only the given paths are staged, never
+ * `git add -A`, so no unrelated working-tree change is swept into the init commit.
+ */
+function initStorage(root, files = scaffoldFiles(), message = exports.INIT_COMMIT_MESSAGE) {
+    for (const file of files) {
+        (0, document_1.writeDocument)((0, path_1.join)(root, file.path), file.content);
+    }
+    return (0, commit_1.commitPaths)(root, files.map((file) => file.path), message);
+}
+//# sourceMappingURL=layout.js.map

package/dist/storage/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/storage/layout.ts"],"names":[],"mappings":";;;AAsEA,sCASC;AAWD,kCASC;AAnGD;;;;;;;;;;;;GAYG;AACH,+BAA4B;AAE5B,qCAAuC;AACvC,yCAA2C;AAE3C,sGAAsG;AACzF,QAAA,YAAY,GAAG,WAAW,CAAC;AAExC,qGAAqG;AACxF,QAAA,mBAAmB,GAAG,uDAAuD,CAAC;AAU3F,qGAAqG;AACrG,oGAAoG;AACpG,MAAM,QAAQ,GAAG,+EAA+E,CAAC;AACjG,MAAM,WAAW,GAAG,6EAA6E,CAAC;AAClG,MAAM,cAAc,GAAG,+EAA+E,CAAC;AACvG,qGAAqG;AACrG,oGAAoG;AACpG,4FAA4F;AAC5F,MAAM,OAAO,GAAG,EAAE,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,aAAa;IAC3B,OAAO;QACL,EAAE,IAAI,EAAE,GAAG,oBAAY,+BAA+B,EAAE,OAAO,EAAE,OAAO,EAAE;QAC1E,EAAE,IAAI,EAAE,GAAG,oBAAY,6BAA6B,EAAE,OAAO,EAAE,OAAO,EAAE;QACxE,EAAE,IAAI,EAAE,GAAG,oBAAY,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE;QACvD,EAAE,IAAI,EAAE,GAAG,oBAAY,kBAAkB,EAAE,OAAO,EAAE,OAAO,EAAE;QAC7D,EAAE,IAAI,EAAE,GAAG,oBAAY,cAAc,EAAE,OAAO,EAAE,WAAW,EAAE;QAC7D,EAAE,IAAI,EAAE,GAAG,oBAAY,iBAAiB,EAAE,OAAO,EAAE,cAAc,EAAE;KACpE,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,WAAW,CACzB,IAAY,EACZ,QAAiC,aAAa,EAAE,EAChD,UAAkB,2BAAmB;IAErC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAA,wBAAa,EAAC,IAAA,WAAI,EAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,IAAA,oBAAW,EAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACpE,CAAC"}

package/dist/storage/memory-path.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Render a `path` pattern against a set of concrete placeholder values.
+ *
+ * @throws {@link StorageError} `E_MISSING_PATH_VALUE` naming every `{placeholder}` in `pattern`
+ *   that has no corresponding key in `values` (all missing values are reported together, not just
+ *   the first).
+ */
+export declare function renderMemoryPath(pattern: string, values: Record<string, string>): string;
+/** Render `pattern` (see {@link renderMemoryPath}) and resolve it to an absolute path under `root`. */
+export declare function resolveMemoryPath(root: string, pattern: string, values: Record<string, string>): string;
+/**
+ * Render + resolve a Memory-entry path (see {@link resolveMemoryPath}) **and enforce storage
+ * confinement (REQ-SEC-06)**: the absolute target must be strictly inside the project `root`.
+ * `path.join`/`resolve` normalize `../`, so a crafted `id` (or any placeholder value) containing
+ * traversal could otherwise steer the write outside the managed, git-tracked store that REQ-SYS-01
+ * establishes as project truth — this refuses that **before** returning a path, so no caller ever
+ * writes outside the root.
+ *
+ * The boundary itself is {@link escapesRoot} (`./confinement.ts`), shared with every other store so
+ * that "inside the project root" has one definition. It is asked **twice, about two resolutions of
+ * the same path**, because a string and a filesystem answer different questions and a Memory write
+ * has to survive both (`task-105`, `bug-117-memory-add-writes-outside-the-project-root-through-a-symlinked-store`):
+ *
+ * 1. **Textually** (`task-017`) — what the rendered pattern *says*. An ordinary `../` smuggled
+ *    through a placeholder value is caught by **either** check, so that case alone would not justify
+ *    keeping this one. What only this check decides is the **laundered** traversal: with a symlink
+ *    outside the root pointing back into it, `resolveRealPathInRoot(root, '…/../../link/x.md')`
+ *    reports `within: true` for a string that plainly climbs out of the project. The string is what
+ *    the project declared, and a link that whoever owns the directory *above* the root can repoint
+ *    at any moment does not get to ratify it. Pinned by `refuses a rendered traversal that the
+ *    filesystem would launder back inside the root`
+ *    (`test/storage/memory-path-confinement.test.ts`) — deleting this check reds that test and, of
+ *    the 35 tests in the five suites over this path, only that one.
+ * 2. **On the filesystem** ({@link resolveRealPathInRoot}) — where the write will actually land. A
+ *    symlinked type directory puts the document outside the root with no traversal anywhere in the
+ *    string, so the textual answer is "inside" and the write is outside; that is `bug-044`'s
+ *    crossing in the store REQ-SEC-06 is written for. A filesystem answer exists even for a path not
+ *    yet created: `resolveRealPathInRoot` resolves as far as the filesystem goes and keeps the
+ *    missing tail verbatim, which is exactly this case — the document is about to be created.
+ *
+ * The second read resolves against the **working tree** rather than `HEAD`, deliberately and against
+ * `command-baseline`'s general rule for a gating read. The argument is `task-102`'s, recorded in
+ * `dl-086-a-guard-over-a-filesystem-effect-resolves-on-the-filesystem` (`in-discussion`) and not
+ * re-derived here: what this predicts is where `writeFileSync` will land, and it follows the symlinks
+ * that are on disk, not the ones a commit records.
+ *
+ * **The target's parent is resolved; its own name is not** — the asymmetry is
+ * {@link resolveRealPathInRoot}'s contract (see that function), and it is the reason this returns a
+ * path spelled under `root` **as the caller gave it** rather than under the real root: `commitPaths`
+ * runs `git -C <root>` and callers take `relative(root, …)`, so re-spelling a legitimate path would
+ * take it out of the repository's own vocabulary.
+ *
+ * Unresolved is not the same as unexamined, and on this path it could not be (task-106,
+ * `bug-120-a-symlinked-document-leaf-is-followed-by-the-write`). Every caller of this function
+ * writes — `writeMemoryEntry` (`../memory/entry.ts`) and `memoryAddFn` (`../core/index.ts`), which
+ * resolves the same path a second time to guard it — and `writeFileSync` **follows** a symlinked
+ * leaf, so accepting one put an element outside the project root and a `wf(<type>): add <id>`
+ * subject in history for it. A third check therefore refuses a target whose own name is a link
+ * ({@link targetIsSymlink}), without resolving it: where the link points is not judged, so the
+ * `bug-044` case that keeps a symlinked file *removable* is untouched — that is a delete, and this
+ * resolver serves no deletes. `dl-086` carries the baseline argument for both.
+ *
+ * @returns the absolute, confinement-verified target path, spelled under `root`.
+ * @throws {@link StorageError} `E_PATH_ESCAPES_ROOT` (message: {@link CONFINEMENT_MESSAGE} plus the
+ *   two spellings of the path, since the two differing is the finding) when the resolved path is the
+ *   root itself, escapes it textually, or lands outside it on the filesystem.
+ * @throws {@link StorageError} `E_TARGET_IS_SYMLINK` (message: `symlinkTargetRefusal`, shared with
+ *   the transition verbs' `CoreResult` refusal) when the target itself is a symbolic link —
+ *   including a **dangling** one, which `existsSync` cannot see.
+ */
+export declare function resolveConfinedMemoryPath(root: string, pattern: string, values: Record<string, string>): string;
+//# sourceMappingURL=memory-path.d.ts.map

package/dist/storage/memory-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-path.d.ts","sourceRoot":"","sources":["../../src/storage/memory-path.ts"],"names":[],"mappings":"AAsBA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAiBxF;AAED,uGAAuG;AACvG,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAsBR"}

package/dist/storage/memory-path.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMemoryPath = renderMemoryPath;
+exports.resolveMemoryPath = resolveMemoryPath;
+exports.resolveConfinedMemoryPath = resolveConfinedMemoryPath;
+/**
+ * Memory document path resolution (task-003-git-backed-sot, spec-001-memory-yaml-schema
+ * `MemoryTypeEntry.path`). A type's `path` pattern (e.g. `docs/04_memory/{release}/{id}.md` for
+ * `task`) MAY contain named placeholders besides `{id}`; spec-001 says those are "resolved by the
+ * Workflow pillar from the active `element:` chain before the ID engine runs". This module is the
+ * one place that renders any such pattern against concrete values — no other code may hardcode a
+ * Memory document path.
+ *
+ * This does not itself generate `{id}` from a counter — that is the ID-generation engine's job
+ * (`src/validation/id.ts`, task-002-validation-id-engine); callers pass the already-generated id in
+ * `values` like any other placeholder.
+ */
+const path_1 = require("path");
+const confinement_1 = require("./confinement");
+const errors_1 = require("./errors");
+/** Exact confinement-violation message required by REQ-SEC-06's fit criterion — do not reword. */
+const CONFINEMENT_MESSAGE = 'Memory entries must reside within the project root';
+const PLACEHOLDER_RE = /\{([^{}]+)\}/g;
+/**
+ * Render a `path` pattern against a set of concrete placeholder values.
+ *
+ * @throws {@link StorageError} `E_MISSING_PATH_VALUE` naming every `{placeholder}` in `pattern`
+ *   that has no corresponding key in `values` (all missing values are reported together, not just
+ *   the first).
+ */
+function renderMemoryPath(pattern, values) {
+    const missing = [];
+    const rendered = pattern.replace(PLACEHOLDER_RE, (_match, token) => {
+        const value = values[token];
+        if (value === undefined) {
+            missing.push(token);
+            return '';
+        }
+        return value;
+    });
+    if (missing.length > 0) {
+        throw new errors_1.StorageError(errors_1.E_MISSING_PATH_VALUE, `path pattern "${pattern}" is missing value(s) for: ${missing.join(', ')}`);
+    }
+    return rendered;
+}
+/** Render `pattern` (see {@link renderMemoryPath}) and resolve it to an absolute path under `root`. */
+function resolveMemoryPath(root, pattern, values) {
+    return (0, path_1.join)(root, renderMemoryPath(pattern, values));
+}
+/**
+ * Render + resolve a Memory-entry path (see {@link resolveMemoryPath}) **and enforce storage
+ * confinement (REQ-SEC-06)**: the absolute target must be strictly inside the project `root`.
+ * `path.join`/`resolve` normalize `../`, so a crafted `id` (or any placeholder value) containing
+ * traversal could otherwise steer the write outside the managed, git-tracked store that REQ-SYS-01
+ * establishes as project truth — this refuses that **before** returning a path, so no caller ever
+ * writes outside the root.
+ *
+ * The boundary itself is {@link escapesRoot} (`./confinement.ts`), shared with every other store so
+ * that "inside the project root" has one definition. It is asked **twice, about two resolutions of
+ * the same path**, because a string and a filesystem answer different questions and a Memory write
+ * has to survive both (`task-105`, `bug-117-memory-add-writes-outside-the-project-root-through-a-symlinked-store`):
+ *
+ * 1. **Textually** (`task-017`) — what the rendered pattern *says*. An ordinary `../` smuggled
+ *    through a placeholder value is caught by **either** check, so that case alone would not justify
+ *    keeping this one. What only this check decides is the **laundered** traversal: with a symlink
+ *    outside the root pointing back into it, `resolveRealPathInRoot(root, '…/../../link/x.md')`
+ *    reports `within: true` for a string that plainly climbs out of the project. The string is what
+ *    the project declared, and a link that whoever owns the directory *above* the root can repoint
+ *    at any moment does not get to ratify it. Pinned by `refuses a rendered traversal that the
+ *    filesystem would launder back inside the root`
+ *    (`test/storage/memory-path-confinement.test.ts`) — deleting this check reds that test and, of
+ *    the 35 tests in the five suites over this path, only that one.
+ * 2. **On the filesystem** ({@link resolveRealPathInRoot}) — where the write will actually land. A
+ *    symlinked type directory puts the document outside the root with no traversal anywhere in the
+ *    string, so the textual answer is "inside" and the write is outside; that is `bug-044`'s
+ *    crossing in the store REQ-SEC-06 is written for. A filesystem answer exists even for a path not
+ *    yet created: `resolveRealPathInRoot` resolves as far as the filesystem goes and keeps the
+ *    missing tail verbatim, which is exactly this case — the document is about to be created.
+ *
+ * The second read resolves against the **working tree** rather than `HEAD`, deliberately and against
+ * `command-baseline`'s general rule for a gating read. The argument is `task-102`'s, recorded in
+ * `dl-086-a-guard-over-a-filesystem-effect-resolves-on-the-filesystem` (`in-discussion`) and not
+ * re-derived here: what this predicts is where `writeFileSync` will land, and it follows the symlinks
+ * that are on disk, not the ones a commit records.
+ *
+ * **The target's parent is resolved; its own name is not** — the asymmetry is
+ * {@link resolveRealPathInRoot}'s contract (see that function), and it is the reason this returns a
+ * path spelled under `root` **as the caller gave it** rather than under the real root: `commitPaths`
+ * runs `git -C <root>` and callers take `relative(root, …)`, so re-spelling a legitimate path would
+ * take it out of the repository's own vocabulary.
+ *
+ * Unresolved is not the same as unexamined, and on this path it could not be (task-106,
+ * `bug-120-a-symlinked-document-leaf-is-followed-by-the-write`). Every caller of this function
+ * writes — `writeMemoryEntry` (`../memory/entry.ts`) and `memoryAddFn` (`../core/index.ts`), which
+ * resolves the same path a second time to guard it — and `writeFileSync` **follows** a symlinked
+ * leaf, so accepting one put an element outside the project root and a `wf(<type>): add <id>`
+ * subject in history for it. A third check therefore refuses a target whose own name is a link
+ * ({@link targetIsSymlink}), without resolving it: where the link points is not judged, so the
+ * `bug-044` case that keeps a symlinked file *removable* is untouched — that is a delete, and this
+ * resolver serves no deletes. `dl-086` carries the baseline argument for both.
+ *
+ * @returns the absolute, confinement-verified target path, spelled under `root`.
+ * @throws {@link StorageError} `E_PATH_ESCAPES_ROOT` (message: {@link CONFINEMENT_MESSAGE} plus the
+ *   two spellings of the path, since the two differing is the finding) when the resolved path is the
+ *   root itself, escapes it textually, or lands outside it on the filesystem.
+ * @throws {@link StorageError} `E_TARGET_IS_SYMLINK` (message: `symlinkTargetRefusal`, shared with
+ *   the transition verbs' `CoreResult` refusal) when the target itself is a symbolic link —
+ *   including a **dangling** one, which `existsSync` cannot see.
+ */
+function resolveConfinedMemoryPath(root, pattern, values) {
+    const resolvedRoot = (0, path_1.resolve)(root);
+    const rendered = renderMemoryPath(pattern, values);
+    const target = (0, path_1.resolve)(resolvedRoot, rendered);
+    if ((0, confinement_1.escapesRoot)(resolvedRoot, target)) {
+        throw new errors_1.StorageError(errors_1.E_PATH_ESCAPES_ROOT, `${CONFINEMENT_MESSAGE}: '${rendered}' resolves to '${target}', outside the project root.`);
+    }
+    const onDisk = (0, confinement_1.resolveRealPathInRoot)(resolvedRoot, rendered);
+    if (!onDisk.within) {
+        throw new errors_1.StorageError(errors_1.E_PATH_ESCAPES_ROOT, `${CONFINEMENT_MESSAGE}: '${rendered}' resolves to '${onDisk.real}', outside the project root — ` +
+            'a directory on the way to it is a symlink leaving the project.');
+    }
+    if ((0, confinement_1.targetIsSymlink)(target)) {
+        throw new errors_1.StorageError(errors_1.E_TARGET_IS_SYMLINK, (0, confinement_1.symlinkTargetRefusal)('create', rendered));
+    }
+    return target;
+}
+//# sourceMappingURL=memory-path.js.map

package/dist/storage/memory-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-path.js","sourceRoot":"","sources":["../../src/storage/memory-path.ts"],"names":[],"mappings":";;AA6BA,4CAiBC;AAGD,8CAMC;AA8DD,8DA0BC;AA/ID;;;;;;;;;;;GAWG;AACH,+BAAqC;AAErC,+CAA0G;AAC1G,qCAAwG;AAExG,kGAAkG;AAClG,MAAM,mBAAmB,GAAG,oDAAoD,CAAC;AAEjF,MAAM,cAAc,GAAG,eAAe,CAAC;AAEvC;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAAC,OAAe,EAAE,MAA8B;IAC9E,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,KAAa,EAAE,EAAE;QACzE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACpB,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,qBAAY,CACpB,6BAAoB,EACpB,iBAAiB,OAAO,8BAA8B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3E,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,uGAAuG;AACvG,SAAgB,iBAAiB,CAC/B,IAAY,EACZ,OAAe,EACf,MAA8B;IAE9B,OAAO,IAAA,WAAI,EAAC,IAAI,EAAE,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,SAAgB,yBAAyB,CACvC,IAAY,EACZ,OAAe,EACf,MAA8B;IAE9B,MAAM,YAAY,GAAG,IAAA,cAAO,EAAC,IAAI,CAAC,CAAC;IACnC,MAAM,QAAQ,GAAG,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACnD,MAAM,MAAM,GAAG,IAAA,cAAO,EAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAC/C,IAAI,IAAA,yBAAW,EAAC,YAAY,EAAE,MAAM,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,qBAAY,CACpB,4BAAmB,EACnB,GAAG,mBAAmB,MAAM,QAAQ,kBAAkB,MAAM,8BAA8B,CAC3F,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,IAAA,mCAAqB,EAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAC7D,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACnB,MAAM,IAAI,qBAAY,CACpB,4BAAmB,EACnB,GAAG,mBAAmB,MAAM,QAAQ,kBAAkB,MAAM,CAAC,IAAI,gCAAgC;YAC/F,gEAAgE,CACnE,CAAC;IACJ,CAAC;IACD,IAAI,IAAA,6BAAe,EAAC,MAAM,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,qBAAY,CAAC,4BAAmB,EAAE,IAAA,kCAAoB,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxF,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/storage/snapshot.d.ts

@@ -0,0 +1,16 @@
+/** One entry of a state snapshot: a root-relative, POSIX-separated path and its recorded content. */
+export interface SnapshotEntry {
+    /** Path relative to the project root, always POSIX-separated (`/`) regardless of platform. */
+    readonly path: string;
+    /** Full raw content for `.wingfoil/**` files; frontmatter-only text for Memory `.md` documents. */
+    readonly content: string;
+}
+/**
+ * Compute a deterministic snapshot of all git-backed WingFoil state under `root` (a resolved
+ * project root — see `./git-root`). No file outside `.wingfoil/` and `docs/04_memory/**\/*.md` is
+ * read; no cache is kept between calls.
+ */
+export declare function computeStateSnapshot(root: string): SnapshotEntry[];
+/** Deterministic string serialization of a snapshot, for byte-identical comparison (REQ-SYS-01). */
+export declare function serializeSnapshot(entries: readonly SnapshotEntry[]): string;
+//# sourceMappingURL=snapshot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/storage/snapshot.ts"],"names":[],"mappings":"AAoBA,qGAAqG;AACrG,MAAM,WAAW,aAAa;IAC5B,8FAA8F;IAC9F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mGAAmG;IACnG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AA8BD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAclE;AAED,oGAAoG;AACpG,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAE3E"}

package/dist/storage/snapshot.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStateSnapshot = computeStateSnapshot;
+exports.serializeSnapshot = serializeSnapshot;
+/**
+ * State snapshot (task-003-git-backed-sot) — the direct implementation of REQ-SYS-01's SARD fit
+ * criterion (docs/02_requirements/03_sard/01_architecture.md):
+ *
+ *   "A fresh git clone of the repository reconstructs 100% of Memory/DNA/Directives/Workflow state
+ *   with no external data source; a state dump before and after clone is byte-identical."
+ *
+ * `computeStateSnapshot` is a pure function of what's on disk under `root`: every file under
+ * `.wingfoil/` in full (DNA/Directives/Workflow config, per spec-011-storage-layout's directory
+ * layout) plus every `docs/04_memory/**\/*.md` document's frontmatter only (Memory content — state
+ * lives in frontmatter, CLAUDE.md §5 / REQ-STATE-01/-02, so the body text isn't part of "state").
+ * It holds no module-level cache and consults nothing outside `root`, so recomputing it — from the
+ * original working copy, from a fresh clone, or from a freshly re-imported module — always yields
+ * the same result for the same on-disk bytes.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const frontmatter_1 = require("./frontmatter");
+function toPosixRelative(root, absolute) {
+    return (0, path_1.relative)(root, absolute).split(path_1.sep).join('/');
+}
+/**
+ * Recursively list every regular file under `dir`, as root-relative POSIX paths, sorted
+ * lexicographically. Directory-entry order from `readdirSync` is not guaranteed stable across
+ * filesystems/platforms, so traversal always sorts explicitly (REQ-SYS-07: no unordered iteration
+ * in a context-building path) rather than trusting it. Returns `[]` if `dir` doesn't exist.
+ */
+function listFilesSorted(root, dir) {
+    if (!(0, fs_1.existsSync)(dir) || !(0, fs_1.statSync)(dir).isDirectory())
+        return [];
+    const out = [];
+    const walk = (current) => {
+        for (const entry of (0, fs_1.readdirSync)(current).sort()) {
+            const full = (0, path_1.join)(current, entry);
+            if ((0, fs_1.statSync)(full).isDirectory()) {
+                walk(full);
+            }
+            else {
+                out.push(full);
+            }
+        }
+    };
+    walk(dir);
+    return out.map((absolute) => toPosixRelative(root, absolute)).sort();
+}
+/**
+ * Compute a deterministic snapshot of all git-backed WingFoil state under `root` (a resolved
+ * project root — see `./git-root`). No file outside `.wingfoil/` and `docs/04_memory/**\/*.md` is
+ * read; no cache is kept between calls.
+ */
+function computeStateSnapshot(root) {
+    const entries = [];
+    for (const path of listFilesSorted(root, (0, path_1.join)(root, '.wingfoil'))) {
+        entries.push({ path, content: (0, fs_1.readFileSync)((0, path_1.join)(root, path), 'utf-8') });
+    }
+    for (const path of listFilesSorted(root, (0, path_1.join)(root, 'docs', '04_memory'))) {
+        if (!path.endsWith('.md'))
+            continue;
+        const raw = (0, fs_1.readFileSync)((0, path_1.join)(root, path), 'utf-8');
+        entries.push({ path, content: (0, frontmatter_1.extractFrontmatter)(raw) ?? '' });
+    }
+    return entries.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+/** Deterministic string serialization of a snapshot, for byte-identical comparison (REQ-SYS-01). */
+function serializeSnapshot(entries) {
+    return entries.map((entry) => `${entry.path}\n${entry.content}`).join('\n---ENTRY---\n');
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/storage/snapshot.js.map

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