wingfoil 0.2.1

package/dist/memory/query.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E_EMPTY_SEARCH_QUERY = void 0;
+exports.computeMemoryContentRoots = computeMemoryContentRoots;
+exports.listMemoryDocumentPaths = listMemoryDocumentPaths;
+exports.loadMemoryDocumentSummary = loadMemoryDocumentSummary;
+exports.findMemoryDocumentById = findMemoryDocumentById;
+exports.listMemoryDocumentsByType = listMemoryDocumentsByType;
+exports.findMemoryDocumentByTypeAndId = findMemoryDocumentByTypeAndId;
+exports.validateSearchQuery = validateSearchQuery;
+exports.searchMemoryDocuments = searchMemoryDocuments;
+/**
+ * Memory query primitives (task-008-dna-memory-query-latency, REQ-PERF-02; match/rank algorithm and
+ * empty-query validation hardened by task-023-implement-keyword-search, P1.12) — the performance-
+ * bearing foundation `wingfoil memory search` (task-021-implement-memory-search, P1.5) builds its
+ * CLI/MCP surface on top of. Deliberately NOT wired into `src/core`'s `CORE_MODULES` registry yet
+ * (see the task's Execution Notes for the scoping decision): this module ships the scan +
+ * keyword/frontmatter relevance primitives plus the query-validation guard, not the `--tag` CLI
+ * grammar, output rendering, or the "no documents matched" exit-code contract, which are task-021's
+ * own scope.
+ *
+ * Three things keep this fast and correct at the 1,000-Memory-document reference scale (REQ-PERF-02)
+ * and satisfy P1.12's fit criteria:
+ *
+ * - **Path-pattern-derived scan roots** (spec-011-storage-layout): rather than walking the whole
+ *   project tree, {@link computeMemoryContentRoots} derives the minimal set of directories to scan
+ *   from `memory.yaml`'s per-type `path` patterns (spec-001-memory-yaml-schema) — the same
+ *   predictability spec-011 calls out as what keeps `memory search`/`history` from needing a
+ *   full-repo walk for every query.
+ * - **Deterministic keyword/frontmatter relevance, not full-text/semantic search**
+ *   (spec-012-context-loader-relevance-filtering's discipline, applied here to `memory search`
+ *   rather than the Agent Context Loader spec-012 itself defines): a metadata match (title/id/tag)
+ *   ranks above a body-only match (P1.12-keyword-search.feature Scenario 1), case-insensitive
+ *   substring matching (Scenario 2), sorted with a total, deterministic order (REQ-SYS-07: no
+ *   unordered iteration in a query-building path). Both were already satisfied by
+ *   {@link searchMemoryDocuments} as shipped by task-008 — task-023 verified this against P1.12's
+ *   fit criteria and added characterization tests, no algorithm change was needed.
+ * - **Empty-query rejection** ({@link validateSearchQuery}, P1.12-keyword-search.feature Scenario 3):
+ *   a genuine gap task-008 left open (an empty query previously matched every document instead of
+ *   being rejected) — task-023 closed it with a `ValidationError.semantic` guard a caller runs before
+ *   invoking {@link searchMemoryDocuments}, exiting 2 with message "empty search query".
+ *
+ * **Archived-exclusion (REQ-STATE-06, task-038-deprecated-excluded-from-context; set widened by
+ * `dl-028-archived-states-excluded-from-context`):** {@link searchMemoryDocuments} excludes documents
+ * in an archived state from its default result — an archived document "never appears in … default
+ * `memory search` results" (the SARD Fit Criterion) while staying present on disk and in git history.
+ * The archived set is `{deprecated, superseded}` and the single shared check is
+ * `state-machine.ts`'s {@link isArchivedStatus} (it superseded task-038's `isDeprecatedStatus`), so
+ * the Agent Context Loader relevance-filter (spec-012 §6, `src/core/relevance.ts`) applies the same
+ * predicate rather than re-deciding what "archived" means. {@link MemorySearchOptions.includeArchived}
+ * is the explicit opt-out.
+ *
+ * `draft` is deliberately NOT excluded here: spec-012 §6 excludes drafts from an assembled agent
+ * *context*, but REQ-STATE-06 scopes default-search exclusion to archived content only, so a draft
+ * document a user is actively working on stays findable. The two filters are different sets on purpose.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const validation_1 = require("../validation");
+const state_machine_1 = require("./state-machine");
+const storage_1 = require("../storage");
+/**
+ * The static (placeholder-free) directory prefix of a `memory.yaml` type `path` pattern — e.g.
+ * `"docs/04_memory/design/adrs/{id}.md"` -> `"docs/04_memory/design/adrs"`. A pattern whose first
+ * placeholder sits in the directory portion (e.g. task's `"docs/04_memory/{release}/{id}.md"`)
+ * collapses to the parent of that placeholder — `"docs/04_memory"` — because every possible
+ * `{release}` value lives under it.
+ */
+function staticDirPrefix(pattern) {
+    const braceIndex = pattern.indexOf('{');
+    const staticPart = braceIndex === -1 ? pattern : pattern.slice(0, braceIndex);
+    const lastSlash = staticPart.lastIndexOf('/');
+    return lastSlash === -1 ? '' : staticPart.slice(0, lastSlash);
+}
+/**
+ * Derive the minimal set of root-relative directories a scan needs to walk to see every Memory
+ * document declared by `memoryYaml`'s types (spec-011: path-pattern predictability, not a full-repo
+ * walk). A directory already covered by another (shorter) directory in the set is dropped, so the
+ * result never contains redundant, nested roots.
+ */
+function computeMemoryContentRoots(memoryYaml) {
+    const dirs = new Set();
+    for (const typeEntry of Object.values(memoryYaml.types)) {
+        const dir = staticDirPrefix(typeEntry.path);
+        if (dir)
+            dirs.add(dir);
+    }
+    const all = [...dirs].sort();
+    return all.filter((dir) => !all.some((other) => other !== dir && dir.startsWith(`${other}/`)));
+}
+/** Recursively list every `.md` file under `root/dir`, as root-relative POSIX paths, sorted. */
+function listMarkdownFilesUnder(root, dir) {
+    const absoluteDir = (0, path_1.join)(root, dir);
+    if (!(0, fs_1.existsSync)(absoluteDir) || !(0, fs_1.statSync)(absoluteDir).isDirectory())
+        return [];
+    const out = [];
+    const walk = (current, relativePrefix) => {
+        for (const entry of (0, fs_1.readdirSync)(current).sort()) {
+            const full = (0, path_1.join)(current, entry);
+            const relative = `${relativePrefix}/${entry}`;
+            if ((0, fs_1.statSync)(full).isDirectory()) {
+                walk(full, relative);
+            }
+            else if (entry.endsWith('.md')) {
+                out.push(relative);
+            }
+        }
+    };
+    walk(absoluteDir, dir);
+    return out;
+}
+/**
+ * List every Memory document under `root`, as root-relative POSIX paths, sorted lexicographically
+ * (REQ-SYS-07 — deterministic, no unordered iteration). Scans only the directories
+ * {@link computeMemoryContentRoots} derives from `memoryYaml`, never the whole project tree.
+ */
+function listMemoryDocumentPaths(root, memoryYaml) {
+    const out = new Set();
+    for (const dir of computeMemoryContentRoots(memoryYaml)) {
+        for (const path of listMarkdownFilesUnder(root, dir))
+            out.add(path);
+    }
+    return [...out].sort();
+}
+/**
+ * Read one Memory document and split it into its parsed frontmatter and body text, without running
+ * it through any type's Zod schema — `memory search`/`history` must handle documents of every type
+ * and any (even structurally imperfect) state, so this is a read, never a validation.
+ */
+function loadMemoryDocumentSummary(root, relativePath) {
+    const absolute = (0, path_1.join)(root, relativePath);
+    const raw = (0, storage_1.readDocument)(absolute);
+    const { frontmatter: frontmatterText, body } = (0, storage_1.splitFrontmatter)(raw);
+    let frontmatter = {};
+    if (frontmatterText) {
+        const parsed = (0, validation_1.parseYaml)(frontmatterText, absolute);
+        if (parsed !== null && typeof parsed === 'object')
+            frontmatter = parsed;
+    }
+    return { path: relativePath, frontmatter, body };
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Resolve a single Memory document by its `id` frontmatter value alone — REQ-PERF-04 /
+ * task-009-mcp-resource-fetch-latency's Acceptance Criteria, which name a `wingfoil://memory/{id}`
+ * benchmark fetch. This is NOT spec-004-mcp-surface-contract §2.1's Resource addressing: spec-004's
+ * actual scheme is `wingfoil://memory/{type}` (collection listing) and `wingfoil://memory/{type}/{id}`
+ * (single document) — there is no bare, single-segment `wingfoil://memory/{id}` form there, and this
+ * `{id}` segment would collide with spec-004's `{type}` segment. task-011-mcp-resources-read-only has
+ * since replaced the `wingfoil://memory/{id}` *Resource* this primitive originally backed with the
+ * conformant `wingfoil://memory/{type}/{id}` form (see {@link findMemoryDocumentByTypeAndId}) — this
+ * bare-id primitive itself is left in place (still covered by its own `test/memory/query.test.ts`
+ * unit tests and REQ-PERF-04's ported benchmark) as a generic, type-agnostic lookup; nothing in
+ * `src/mcp` calls it anymore.
+ *
+ * A linear scan over every document {@link listMemoryDocumentPaths} returns, in its
+ * already-deterministic sorted order, stopping at the first document whose frontmatter `id` matches
+ * *exactly* (never a substring — that remains `searchMemoryDocuments`'/task-021's keyword-search
+ * surface, not this primitive's). Returns `undefined` — never throws — when no document matches;
+ * turning that into a protocol-level "resource not found" failure is the MCP Resource adapter's job
+ * (spec-004 §2.2's general unresolvable-URI contract), not this primitive's.
+ */
+function findMemoryDocumentById(root, memoryYaml, id) {
+    for (const path of listMemoryDocumentPaths(root, memoryYaml)) {
+        const summary = loadMemoryDocumentSummary(root, path);
+        if (asString(summary.frontmatter.id) === id)
+            return summary;
+    }
+    return undefined;
+}
+/**
+ * List every Memory document whose frontmatter `type:` field equals `type` (a `memory.yaml` `types:`
+ * key), as frontmatter-only summaries — spec-004 §2.1's `wingfoil://memory/{type}` collection
+ * addressing (task-011-mcp-resources-read-only, REQ-INT-01). Sorted by `id` (falling back to `path`
+ * when a document has no `id`) ascending (REQ-SYS-07 — deterministic, no unordered iteration).
+ *
+ * Membership is decided by each document's own frontmatter `type:` field, not by which directory it
+ * lives in: several types' `path` patterns collapse to the *same* static directory prefix (e.g.
+ * `release`/`release-line` both resolve to `docs/04_memory/planning`; `task`'s own pattern collapses
+ * all the way to `docs/04_memory` itself — see {@link computeMemoryContentRoots}'s doc comment), so a
+ * directory-only filter would wrongly fold sibling types' documents into this type's collection.
+ */
+function listMemoryDocumentsByType(root, memoryYaml, type) {
+    const out = [];
+    for (const path of listMemoryDocumentPaths(root, memoryYaml)) {
+        const { frontmatter } = loadMemoryDocumentSummary(root, path);
+        if (asString(frontmatter.type) !== type)
+            continue;
+        out.push({
+            path,
+            id: asString(frontmatter.id),
+            title: asString(frontmatter.title),
+            status: asString(frontmatter.status),
+            tags: asStringArray(frontmatter.tags),
+        });
+    }
+    return out.sort((a, b) => {
+        const keyA = a.id ?? a.path;
+        const keyB = b.id ?? b.path;
+        return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+    });
+}
+/**
+ * Resolve a single Memory document by (`type`, `id`) — spec-004 §2.1's `wingfoil://memory/{type}/{id}`
+ * single-document addressing (task-011-mcp-resources-read-only, REQ-INT-01), the conformant
+ * replacement for task-009's bare-`{id}` `findMemoryDocumentById` Resource usage. Both `type` and `id`
+ * must match a document's own frontmatter — same directory-collision reasoning as
+ * {@link listMemoryDocumentsByType} — so this never returns a document of a *different* type merely
+ * because that type's path pattern happens to also resolve under the same directory. Returns
+ * `undefined` — never throws — when nothing matches; surfacing that as a protocol-level "resource not
+ * found" failure is the MCP Resource adapter's job (spec-004 §2.2), not this primitive's.
+ */
+function findMemoryDocumentByTypeAndId(root, memoryYaml, type, id) {
+    for (const path of listMemoryDocumentPaths(root, memoryYaml)) {
+        const summary = loadMemoryDocumentSummary(root, path);
+        if (asString(summary.frontmatter.type) === type && asString(summary.frontmatter.id) === id)
+            return summary;
+    }
+    return undefined;
+}
+/** `E_EMPTY_SEARCH_QUERY` field-level code (spec-009-validation-strategy §3) for a rejected empty
+ * or whitespace-only `wingfoil memory search` query. */
+exports.E_EMPTY_SEARCH_QUERY = 'E_EMPTY_SEARCH_QUERY';
+/**
+ * Reject an empty or whitespace-only search query (P1.12 BDD Scenario "Error - empty query string":
+ * "no search is performed" and exit code 2, message "empty search query"). Mirrors
+ * `resolveTransitionTarget`'s `ValidationError.semantic` pattern (`./state-machine.ts`) so the shared
+ * exit-code mapping (spec-009 §3) surfaces this as exit 2 without a bespoke error path; task-021's
+ * `wingfoil memory search` CLI/MCP surface calls this on the user-supplied query string before it
+ * ever reaches {@link searchMemoryDocuments}.
+ *
+ * Deliberately a separate guard, not a change to `searchMemoryDocuments`'s own signature/behavior:
+ * `searchMemoryDocuments(root, memoryYaml, '', { tag })` remains a legitimate "browse by tag alone,
+ * no keyword" call (task-008's own characterization test) — the empty-query rejection is this task's
+ * (P1.12's) algorithm-level validation concern, applied at the point a *user-facing* query string is
+ * about to be searched, not baked into the lower-level scan primitive that also serves tag-only
+ * listing.
+ */
+function validateSearchQuery(query) {
+    if (query.trim().length === 0) {
+        throw validation_1.ValidationError.semantic([
+            { code: exports.E_EMPTY_SEARCH_QUERY, path: '', file: '', message: 'empty search query' },
+        ]);
+    }
+}
+/**
+ * Deterministic keyword/frontmatter search over every Memory document `memoryYaml` declares
+ * (P1.5/P1.12): case-insensitive substring matching against title/id/tags (metadata) and body text,
+ * optionally narrowed to one exact `tag`. A query that matches nothing returns `[]` — a successful,
+ * empty result, never a thrown error (that "no documents matched" outcome is a CLI/MCP-surface
+ * concern, task-021's, not this primitive's).
+ *
+ * Ordering is a total, deterministic order (REQ-SYS-07): metadata matches before body-only matches,
+ * then by `id` (falling back to `path` when a document has no `id`) ascending — so calling this
+ * twice against unchanged state always returns the exact same array.
+ *
+ * **REQ-STATE-06:** a document whose frontmatter `status` is archived — `deprecated` or `superseded`
+ * (`isArchivedStatus`, `dl-028`) — is excluded by default, so it never appears in these "default
+ * `memory search` results", matching the Fit Criterion verbatim, while the file itself is untouched on
+ * disk and in git history (`memory deprecate`, P1.9, never deletes it; `superseded` is reached by an
+ * ordinary `approve`). Pass `options.includeArchived: true` for the one legitimate exception: an
+ * explicit, intentional request to see archived documents too. `draft` documents are NOT excluded
+ * here — see this module's header for why the search set and the context set differ.
+ */
+function searchMemoryDocuments(root, memoryYaml, query, options = {}) {
+    const needle = query.trim().toLowerCase();
+    const matches = [];
+    for (const path of listMemoryDocumentPaths(root, memoryYaml)) {
+        const { frontmatter, body } = loadMemoryDocumentSummary(root, path);
+        const status = asString(frontmatter.status);
+        if (!options.includeArchived && (0, state_machine_1.isArchivedStatus)(status))
+            continue;
+        const tags = asStringArray(frontmatter.tags);
+        if (options.tag && !tags.includes(options.tag))
+            continue;
+        const title = asString(frontmatter.title);
+        const id = asString(frontmatter.id);
+        const type = asString(frontmatter.type);
+        let metadataMatch = false;
+        let bodyMatch = false;
+        if (needle.length > 0) {
+            metadataMatch =
+                (title !== undefined && title.toLowerCase().includes(needle)) ||
+                    (id !== undefined && id.toLowerCase().includes(needle)) ||
+                    tags.some((tag) => tag.toLowerCase().includes(needle));
+            bodyMatch = body.toLowerCase().includes(needle);
+            if (!metadataMatch && !bodyMatch)
+                continue;
+        }
+        matches.push({ path, id, title, tags, status, type, metadataMatch, bodyMatch });
+    }
+    return matches.sort((a, b) => {
+        const scoreA = a.metadataMatch ? 1 : 0;
+        const scoreB = b.metadataMatch ? 1 : 0;
+        if (scoreA !== scoreB)
+            return scoreB - scoreA;
+        const keyA = a.id ?? a.path;
+        const keyB = b.id ?? b.path;
+        return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+    });
+}
+//# sourceMappingURL=query.js.map

package/dist/memory/query.js.map

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

package/dist/memory/reject.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The rejected document: `status` set to `target` (the type's `gates.<state>.reject` value, taken
+ * verbatim per `spec-001-memory-yaml-schema`) and `rejection_reason` set to `reason`. Every other byte
+ * — the remaining frontmatter entries, their inline comments, and the whole body — is untouched.
+ *
+ * `reason` is arbitrary user input (`--reason <text>`, `spec-008-cli-grammar` §2), so it is written
+ * through `setFrontmatterField`'s YAML-safe serialization: quotes, colons, `#`, newlines, a leading
+ * `-`, YAML-typed words such as `no`/`null` and unicode all parse back to exactly the text given.
+ */
+export declare function renderRejectDocument(content: string, target: string, reason: string): string;
+//# sourceMappingURL=reject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reject.d.ts","sourceRoot":"","sources":["../../src/memory/reject.ts"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE5F"}

package/dist/memory/reject.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRejectDocument = renderRejectDocument;
+/**
+ * The pure document edit behind `wingfoil memory reject` (P1.8, task-047-memory-reject), kept out of
+ * the `CoreResult`-wrapped operation in `src/core` exactly as `./submit.ts` serves `memory submit`.
+ *
+ * `spec-010-memory-frontmatter-schema`'s field-write ownership table makes `memory.reject` the one
+ * transition verb that writes TWO frontmatter fields — "`memory.reject` changes `status` plus
+ * `rejection_reason` — the one exception to 'status only' among the transition verbs". The reason is
+ * stored verbatim, as the mirror of the `Reason:` trailer the commit body carries (the commit stays
+ * the authoritative audit record, P1.7/REQ-SEC-04); the next `memory.submit` removes the key again
+ * ({@link renderSubmitDocument}), so it always reflects only the most recent reject.
+ *
+ * Deterministic (REQ-SYS-07): a pure function of its arguments, with no clock, randomness or
+ * object-key iteration.
+ */
+const frontmatter_edit_1 = require("./frontmatter-edit");
+const submit_1 = require("./submit");
+/**
+ * The rejected document: `status` set to `target` (the type's `gates.<state>.reject` value, taken
+ * verbatim per `spec-001-memory-yaml-schema`) and `rejection_reason` set to `reason`. Every other byte
+ * — the remaining frontmatter entries, their inline comments, and the whole body — is untouched.
+ *
+ * `reason` is arbitrary user input (`--reason <text>`, `spec-008-cli-grammar` §2), so it is written
+ * through `setFrontmatterField`'s YAML-safe serialization: quotes, colons, `#`, newlines, a leading
+ * `-`, YAML-typed words such as `no`/`null` and unicode all parse back to exactly the text given.
+ */
+function renderRejectDocument(content, target, reason) {
+    return (0, frontmatter_edit_1.setFrontmatterField)((0, frontmatter_edit_1.setFrontmatterField)(content, 'status', target), submit_1.REJECTION_REASON_FIELD, reason);
+}
+//# sourceMappingURL=reject.js.map

package/dist/memory/reject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject.js","sourceRoot":"","sources":["../../src/memory/reject.ts"],"names":[],"mappings":";;AA0BA,oDAEC;AA5BD;;;;;;;;;;;;;GAaG;AACH,yDAAyD;AACzD,qCAAkD;AAElD;;;;;;;;GAQG;AACH,SAAgB,oBAAoB,CAAC,OAAe,EAAE,MAAc,EAAE,MAAc;IAClF,OAAO,IAAA,sCAAmB,EAAC,IAAA,sCAAmB,EAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,+BAAsB,EAAE,MAAM,CAAC,CAAC;AAC7G,CAAC"}

package/dist/memory/schema.d.ts

@@ -0,0 +1,104 @@
+/**
+ * MemoryYaml schema (spec-001-memory-yaml-schema) — the Project Memory type registry (P1.13). This
+ * is one of the three independent per-pillar schemas task-004-decoupled-pillars keeps decoupled
+ * (REQ-SYS-02): it has no dependency on `dna.yaml`'s or `workflows.yaml`'s schema, and its own
+ * validation never inspects any other file.
+ *
+ * Every object node is `.passthrough()` per spec-009-validation-strategy §2 (unknown fields are
+ * preserved and warned about, not fatal) — see `src/core/loaders.ts` for the loader that wires this
+ * schema through the shared two-pass pipeline.
+ */
+import { z } from 'zod';
+/**
+ * The sequence/gates/waiting state-machine encoding (spec-001 "Sub-schema: StateMachine"),
+ * replacing the earlier ambiguous `transitions: {state: [target, ...]}` dict-of-arrays format.
+ *
+ * The semantic rules from spec-001's "Semantic validation (post-parse)" section are embedded here
+ * as a `.superRefine()` — spec-009 §1 frames exactly this kind of same-document, cross-field rule
+ * ("a phase's `gates` key must reference a step name that is itself a member of that phase's
+ * `sequence` array") as expressible via `.superRefine()`, "still inside the Zod schema, logically
+ * Pass 2":
+ *
+ * - Every key in `gates` and every entry in `waiting` MUST be a member of `sequence`.
+ * - A `gates.<state>.reject` target need NOT be a member of `sequence` (it may revert into the
+ *   chain or name an off-chain decline state reached by no forward edge).
+ * - The literal string `"deprecated"` is reserved: it may not appear in `sequence`, as a `gates`
+ *   key, as a `gates.<state>.reject` target, or in `waiting` — it is an implicit wildcard edge to a
+ *   reserved state, never declared explicitly.
+ */
+export declare const StateMachine: z.ZodObject<{
+    sequence: z.ZodArray<z.ZodString>;
+    gates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        reject: z.ZodString;
+    }, z.core.$loose>>>;
+    waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type StateMachine = z.infer<typeof StateMachine>;
+/** `template.frontmatter.required` + the scaffold file path a `memory.add --type <t>` copies. */
+export declare const TemplateConfig: z.ZodObject<{
+    frontmatter: z.ZodObject<{
+        required: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    file: z.ZodString;
+}, z.core.$loose>;
+export type TemplateConfig = z.infer<typeof TemplateConfig>;
+/** One `types.<name>` entry — path pattern, id pattern, human metadata, template, state machine. */
+export declare const MemoryTypeEntry: z.ZodObject<{
+    path: z.ZodString;
+    id_pattern: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    template: z.ZodOptional<z.ZodObject<{
+        frontmatter: z.ZodObject<{
+            required: z.ZodArray<z.ZodString>;
+        }, z.core.$loose>;
+        file: z.ZodString;
+    }, z.core.$loose>>;
+    states: z.ZodOptional<z.ZodObject<{
+        sequence: z.ZodArray<z.ZodString>;
+        gates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            reject: z.ZodString;
+        }, z.core.$loose>>>;
+        waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type MemoryTypeEntry = z.infer<typeof MemoryTypeEntry>;
+/**
+ * `memory.yaml`'s top-level shape. `version` is `z.number().positive()`, NOT `.int()` — the file's
+ * `version: 1.0` (and `1.1`) is a YAML float and `.int()` would spuriously reject it (spec-001).
+ */
+export declare const MemoryYaml: z.ZodObject<{
+    version: z.ZodNumber;
+    defaults: z.ZodOptional<z.ZodObject<{
+        states: z.ZodObject<{
+            sequence: z.ZodArray<z.ZodString>;
+            gates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                reject: z.ZodString;
+            }, z.core.$loose>>>;
+            waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    types: z.ZodRecord<z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        id_pattern: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        template: z.ZodOptional<z.ZodObject<{
+            frontmatter: z.ZodObject<{
+                required: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>;
+            file: z.ZodString;
+        }, z.core.$loose>>;
+        states: z.ZodOptional<z.ZodObject<{
+            sequence: z.ZodArray<z.ZodString>;
+            gates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                reject: z.ZodString;
+            }, z.core.$loose>>>;
+            waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type MemoryYaml = z.infer<typeof MemoryYaml>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/memory/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY;;;;;;iBA2DrB,CAAC;AACL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,iGAAiG;AACjG,eAAO,MAAM,cAAc;;;;;iBAKX,CAAC;AACjB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,oGAAoG;AACpG,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;iBAUZ,CAAC;AACjB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CnB,CAAC;AACL,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/memory/schema.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryYaml = exports.MemoryTypeEntry = exports.TemplateConfig = exports.StateMachine = void 0;
+/**
+ * MemoryYaml schema (spec-001-memory-yaml-schema) — the Project Memory type registry (P1.13). This
+ * is one of the three independent per-pillar schemas task-004-decoupled-pillars keeps decoupled
+ * (REQ-SYS-02): it has no dependency on `dna.yaml`'s or `workflows.yaml`'s schema, and its own
+ * validation never inspects any other file.
+ *
+ * Every object node is `.passthrough()` per spec-009-validation-strategy §2 (unknown fields are
+ * preserved and warned about, not fatal) — see `src/core/loaders.ts` for the loader that wires this
+ * schema through the shared two-pass pipeline.
+ */
+const zod_1 = require("zod");
+const RESERVED_STATE = 'deprecated';
+/**
+ * The sequence/gates/waiting state-machine encoding (spec-001 "Sub-schema: StateMachine"),
+ * replacing the earlier ambiguous `transitions: {state: [target, ...]}` dict-of-arrays format.
+ *
+ * The semantic rules from spec-001's "Semantic validation (post-parse)" section are embedded here
+ * as a `.superRefine()` — spec-009 §1 frames exactly this kind of same-document, cross-field rule
+ * ("a phase's `gates` key must reference a step name that is itself a member of that phase's
+ * `sequence` array") as expressible via `.superRefine()`, "still inside the Zod schema, logically
+ * Pass 2":
+ *
+ * - Every key in `gates` and every entry in `waiting` MUST be a member of `sequence`.
+ * - A `gates.<state>.reject` target need NOT be a member of `sequence` (it may revert into the
+ *   chain or name an off-chain decline state reached by no forward edge).
+ * - The literal string `"deprecated"` is reserved: it may not appear in `sequence`, as a `gates`
+ *   key, as a `gates.<state>.reject` target, or in `waiting` — it is an implicit wildcard edge to a
+ *   reserved state, never declared explicitly.
+ */
+exports.StateMachine = zod_1.z
+    .object({
+    sequence: zod_1.z.array(zod_1.z.string()).min(1),
+    gates: zod_1.z.record(zod_1.z.string(), zod_1.z.object({ reject: zod_1.z.string() }).passthrough()).optional(),
+    waiting: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .passthrough()
+    .superRefine((value, ctx) => {
+    const sequenceSet = new Set(value.sequence);
+    value.sequence.forEach((state, index) => {
+        if (state === RESERVED_STATE) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `"${RESERVED_STATE}" is a reserved implicit state and may not appear in \`sequence\``,
+                path: ['sequence', index],
+            });
+        }
+    });
+    for (const [state, gate] of Object.entries(value.gates ?? {})) {
+        if (state === RESERVED_STATE) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `"${RESERVED_STATE}" is a reserved implicit state and may not be declared as a \`gates\` key`,
+                path: ['gates', state],
+            });
+        }
+        else if (!sequenceSet.has(state)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `\`gates\` key "${state}" must be a member of \`sequence\``,
+                path: ['gates', state],
+            });
+        }
+        if (gate.reject === RESERVED_STATE) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `"${RESERVED_STATE}" is a reserved implicit state and may not be a \`gates.<state>.reject\` target`,
+                path: ['gates', state, 'reject'],
+            });
+        }
+        // Note: gate.reject need NOT be a member of `sequence` (spec-001) — no membership check here.
+    }
+    (value.waiting ?? []).forEach((state, index) => {
+        if (state === RESERVED_STATE) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `"${RESERVED_STATE}" is a reserved implicit state and may not be declared in \`waiting\``,
+                path: ['waiting', index],
+            });
+        }
+        else if (!sequenceSet.has(state)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `\`waiting\` entry "${state}" must be a member of \`sequence\``,
+                path: ['waiting', index],
+            });
+        }
+    });
+});
+/** `template.frontmatter.required` + the scaffold file path a `memory.add --type <t>` copies. */
+exports.TemplateConfig = zod_1.z
+    .object({
+    frontmatter: zod_1.z.object({ required: zod_1.z.array(zod_1.z.string()) }).passthrough(),
+    file: zod_1.z.string(),
+})
+    .passthrough();
+/** One `types.<name>` entry — path pattern, id pattern, human metadata, template, state machine. */
+exports.MemoryTypeEntry = zod_1.z
+    .object({
+    path: zod_1.z.string(),
+    id_pattern: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
+    template: exports.TemplateConfig.optional(),
+    states: exports.StateMachine.optional(), // absent ⇒ `defaults.states` applies (REQ-STATE-08)
+})
+    .passthrough();
+/**
+ * `memory.yaml`'s top-level shape. `version` is `z.number().positive()`, NOT `.int()` — the file's
+ * `version: 1.0` (and `1.1`) is a YAML float and `.int()` would spuriously reject it (spec-001).
+ */
+exports.MemoryYaml = zod_1.z
+    .object({
+    version: zod_1.z.number().positive(),
+    defaults: zod_1.z.object({ states: exports.StateMachine }).passthrough().optional(),
+    types: zod_1.z.record(zod_1.z.string(), exports.MemoryTypeEntry),
+})
+    .passthrough()
+    /**
+     * Type-contextualized restatement of spec-001's "Semantic validation (post-parse)" membership rule
+     * — the P1.13 acceptance contract (task-024-implement-memory-element-schema): a state referenced by
+     * a type's machine (a `gates` key or a `waiting` entry) that is NOT one of that type's declared
+     * states (`sequence`) is a malformed schema and must be rejected at load time, **before any document
+     * of that type can be created or transitioned** (REQ-STATE-01). The `StateMachine` sub-schema's own
+     * `.superRefine` already flags the same structural violation, but only this top-level refinement
+     * knows the *owning type name*, so P1.13's required wording
+     * (`transition target '<state>' not in declared states for type '<type>'`) can only be produced
+     * here. `defaults.states` (which has no owning type) is left to the `StateMachine`-level check.
+     *
+     * `gates.<state>.reject` targets are intentionally NOT checked: spec-001 explicitly allows them to
+     * be off-chain ("need **not** be a member of `sequence` ... e.g. `bug`'s `open: { reject: closed }`").
+     * Iteration is over insertion-ordered `Object.entries`/`Object.keys` only — no wall-clock, no
+     * randomness, no set ordering (REQ-SYS-07 determinism).
+     */
+    .superRefine((value, ctx) => {
+    for (const [typeName, entry] of Object.entries(value.types)) {
+        const machine = entry.states;
+        if (!machine)
+            continue; // no own machine ⇒ `defaults.states` applies (REQ-STATE-08)
+        const sequenceSet = new Set(machine.sequence);
+        const flag = (state, path) => {
+            if (state !== RESERVED_STATE && !sequenceSet.has(state)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `transition target '${state}' not in declared states for type '${typeName}'`,
+                    path: ['types', typeName, 'states', ...path],
+                });
+            }
+        };
+        for (const gateState of Object.keys(machine.gates ?? {})) {
+            flag(gateState, ['gates', gateState]);
+        }
+        (machine.waiting ?? []).forEach((waitState, index) => {
+            flag(waitState, ['waiting', index]);
+        });
+    }
+});
+//# sourceMappingURL=schema.js.map