@agentproto/memory 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,50 @@
-# Temporary Holding Version
+# @agentproto/memory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+AIP-72 `memory/v1` reference implementation: define, validate, parse and
+render memory items. A memory item is one small typed assertion (`user`,
+`feedback`, `project`, `reference`) about a principal or its work, with a
+lifecycle (`active`, then `superseded` or `archived`), stored as markdown
+with YAML frontmatter.
+
+Spec: <https://agentproto.sh/docs/aip-72>. This package covers the
+document only; a store port and per-harness projection come later.
+
+## Usage
+
+```ts
+import {
+  defineMemory,
+  parseMemory,
+  renderMemory,
+  validateMemory,
+} from "@agentproto/memory"
+
+// Writer path: canonical fields required, throws MemoryValidationError
+// (with `.field` and `.issues`) on any invalid field.
+const item = defineMemory({
+  schema: "memory/v1",
+  slug: "cite-sources",
+  kind: "feedback",
+  type: "feedback",
+  title: "Cite sources",
+  updated_at: "2026-10-13T11:30:00.000Z",
+  polarity: "do",
+  provenance: { source: "converse", at: "2026-10-13T11:00:00.000Z" },
+  body: "Always cite sources.\n",
+})
+
+const md = renderMemory(item) // every string double-quoted
+const doc = parseMemory(md) // YAML 1.2 core, does not validate
+
+// Reader path: legacy items (id, name, type) are accepted.
+const { ok, errors, warnings } = validateMemory(doc)
+// errors: [{ path: "provenance.sessionId", message, rule: "schema" }, ...]
+```
+
+`defineMemory` fills in only `status: "active"` (a writer creates an item
+active) and an absent `body` as `""`. Lifecycle helpers: `memoryStatus`,
+`isAllowedStatusTransition`, `isInForce`.
+
+## License
+
+Apache-2.0. See [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,365 @@
+import { z } from 'zod';
+
+/**
+ * AIP-72 memory/v1 document types.
+ *
+ * Hand-tuned on top of the shape `json-schema-to-typescript` generates
+ * from `resources/aip-72/draft/MEMORY.schema.json`: the `$defs` get
+ * `Memory*` names, and the document carries its markdown `body` as a
+ * required string (the schema's `body` property stands for the text
+ * after the closing frontmatter fence).
+ */
+declare const MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
+/** The closed memory type set (`type`, and `kind` on a memory/v1 item). */
+type MemoryType = (typeof MEMORY_TYPES)[number];
+declare const MEMORY_STATUSES: readonly ["active", "superseded", "archived"];
+/** Lifecycle status. Absent means `active` (AIP-72 rule 9). */
+type MemoryStatus = (typeof MEMORY_STATUSES)[number];
+interface MemoryAnchor {
+    kind: "global" | "project" | "task" | "session" | "pr" | "contact" | "agent";
+    /** Anchor target slug (project, contact, agent). */
+    slug?: string;
+    /** Anchor target id (task, session). */
+    id?: string;
+    /** Repository `owner/name` for a pr anchor. */
+    repo?: string;
+    /** Pull-request number for a pr anchor. */
+    number?: number;
+}
+interface MemoryLifetime {
+    kind: "durable" | "until" | "while" | "session";
+    /** Expiry timestamp, REQUIRED for kind `until`. */
+    at?: string;
+    /** Governing anchor, REQUIRED for kind `while`. */
+    anchor?: MemoryAnchor;
+}
+interface MemoryDecidedBy {
+    rule?: string;
+    source?: string;
+}
+interface MemoryProvenance {
+    source?: string;
+    /** Omitted, never empty, when the source has no session. */
+    sessionId?: string;
+    /** Omitted, never empty, when the source has none. */
+    ref?: string;
+    quote?: string;
+    at?: string;
+    extractorVersion?: string;
+}
+interface MemoryCapture {
+    mode?: "live" | "batch";
+    producer?: string;
+    capturedAt?: string;
+}
+interface MemoryEvidence {
+    sourceKind?: string;
+    trust?: string;
+    explicitness?: string;
+    corroborations?: number;
+    contradictsActive?: boolean;
+    impact?: string;
+    lifetime?: MemoryLifetime;
+    anchorsResolved?: string[];
+    ageHours?: number;
+    flags?: string[];
+}
+/**
+ * The YAML frontmatter of a memory/v1 item. Every field is optional at
+ * the type level: the schema accepts either the canonical AIP-10 base
+ * fields (`schema`, `slug`, `kind`, `title`, `updated_at`) or the legacy
+ * trio (`id`, `name`, `type`), which `validateMemory` checks.
+ */
+interface MemoryFrontmatter {
+    schema?: "memory/v1";
+    slug?: string;
+    kind?: string;
+    title?: string;
+    updated_at?: string;
+    id?: string;
+    name?: string;
+    type?: MemoryType;
+    description?: string;
+    tags?: string[];
+    polarity?: "do" | "dont";
+    lifetime?: MemoryLifetime;
+    status?: MemoryStatus;
+    created?: string;
+    written?: string;
+    decidedBy?: MemoryDecidedBy;
+    provenance?: MemoryProvenance;
+    evidence?: MemoryEvidence;
+    capture?: MemoryCapture;
+}
+/** One memory/v1 item: frontmatter fields plus the markdown body. */
+interface MemoryDocument extends MemoryFrontmatter {
+    body: string;
+}
+/** `defineMemory` input: `body` may be omitted for an item with no prose. */
+type MemoryDefinition = MemoryFrontmatter & {
+    body?: string;
+};
+/** The frozen item `defineMemory` returns, with `status` made explicit. */
+type MemoryHandle = Readonly<MemoryDocument & {
+    status: MemoryStatus;
+}>;
+/**
+ * One validation finding. `path` is the dot path of the offending field
+ * (`provenance.sessionId`, `lifetime.at`, `tags.0`), `""` for the whole
+ * document. `rule` is `schema` for a MEMORY.schema.json constraint,
+ * `section-2` for the memory/v1 `kind` set, or `rule-<n>` for AIP-72
+ * conformance rule n.
+ */
+interface MemoryIssue {
+    path: string;
+    message: string;
+    rule: string;
+}
+interface MemoryValidationResult {
+    ok: boolean;
+    errors: MemoryIssue[];
+    /** SHOULD-level findings (rule 8). Never make `ok` false. */
+    warnings: MemoryIssue[];
+}
+
+/**
+ * AIP-72 reference implementation of `defineMemory`: the writer path.
+ *
+ * Validates in canonical mode (rule 1: a writer sets `schema`, `slug`,
+ * `kind`, `title`, `updated_at` on every item it creates) and throws a
+ * `MemoryValidationError` whose `field` / `issues` name the offending
+ * field paths. Only two values are filled in: `status` becomes `active`
+ * when absent (section 3: a writer creates an item `active`), and an
+ * absent `body` becomes `""`. Nothing else is defaulted; in particular
+ * `tags` is not set to `[]`, since rule 4 omits an empty optional field.
+ *
+ * Built on `createDoctype` for the shared slug check and top-level
+ * freeze; the handle is frozen deeply and does not alias the input.
+ */
+declare function defineMemory(input: MemoryDefinition): MemoryHandle;
+
+interface ValidateMemoryOptions {
+    /**
+     * Require the canonical fields (`schema`, `slug`, `kind`, `title`,
+     * `updated_at`), as rule 1 asks of a writer creating an item. Off by
+     * default: a reader MUST accept legacy items (rule 9).
+     */
+    canonical?: boolean;
+}
+/**
+ * Validate one memory/v1 document (frontmatter fields plus `body`).
+ *
+ * Runs MEMORY.schema.json (through the generated zod, plus the
+ * `anyOf` and lifetime `if/then` branches the codegen cannot express)
+ * and the AIP-72 conformance rules checkable on a single document:
+ * section 2 (`kind` set), rules 1, 2, 4 and 5 as errors, rule 8 as
+ * warnings. Rules 6 and 7 compare two versions of an item and belong to
+ * the store; `isAllowedStatusTransition` covers rule 7's table.
+ */
+declare function validateMemory(doc: unknown, opts?: ValidateMemoryOptions): MemoryValidationResult;
+
+/**
+ * Split a MEMORY.md file into its frontmatter fields and `body`.
+ *
+ * The frontmatter is read as YAML 1.2 core schema, so a date-time stays
+ * a string and an unquoted `true`, `null` or `2026` in a string field
+ * reaches `validateMemory` as a non-string and fails there (rule 3).
+ * This only parses: it does not validate, so a reader can still load an
+ * item it will then inspect. The body is free (rule 12): one blank line
+ * after the closing fence is the separator, everything after it is kept
+ * byte for byte.
+ */
+declare function parseMemory(markdown: string): MemoryDocument;
+/**
+ * Render a memory/v1 document as MEMORY.md. Throws a
+ * `MemoryValidationError` if the document does not validate.
+ *
+ * Every string value is double-quoted, so a YAML 1.1 or 1.2 reader
+ * reads it back as a string (rule 3); undefined fields are omitted
+ * (rule 4); key order is the document's own, so a status-only rewrite
+ * changes only the `status` line (rule 6). `parseMemory(renderMemory(d))`
+ * deep-equals `d`.
+ */
+declare function renderMemory(doc: MemoryDocument): string;
+
+/** The item's status, reading an absent `status` as `active` (rule 9). */
+declare function memoryStatus(doc: Pick<MemoryFrontmatter, "status">): MemoryStatus;
+/**
+ * Rule 7: a writer only moves `status` from `active` (or absent) to
+ * `superseded` or `archived`, and never out of either. Rewriting the
+ * same status is not a transition and is allowed.
+ */
+declare function isAllowedStatusTransition(from: MemoryStatus | undefined, to: MemoryStatus): boolean;
+/**
+ * Whether a reader may present the item as in force at `now`.
+ *
+ * Rule 10: a `superseded` or `archived` item is not. Rule 11: an
+ * `until` lifetime past its `at` is not. A `while` anchor or a
+ * `session` lifetime needs context outside the document (does the
+ * anchor still hold, which session is current), so this check treats
+ * them as holding; the store that has that context narrows further.
+ */
+declare function isInForce(doc: Pick<MemoryFrontmatter, "status" | "lifetime">, now?: Date): boolean;
+
+/** Thrown by `defineMemory` and `renderMemory` on an invalid item. */
+declare class MemoryValidationError extends Error {
+    /** Every error found, each naming its field path. */
+    readonly issues: readonly MemoryIssue[];
+    /** Path of the first offending field (`""` for the whole document). */
+    readonly field: string;
+    constructor(prefix: string, issues: readonly MemoryIssue[]);
+}
+/** Thrown by `parseMemory` when the markdown has no readable frontmatter. */
+declare class MemoryParseError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * AIP-72 memory/v1 frontmatter zod schema.
+ *
+ * Codegen output of `scripts/scaffold-aip.mjs --aip 72 --slug memory
+ * --doctype MEMORY --schema-only --inline-refs` over
+ * `specs/resources/aip-72/draft/MEMORY.schema.json`. Do not edit the code
+ * below by hand: change the JSON draft, then regenerate.
+ * `scripts/check-spec-drift.mjs` fails CI when the code drifts from the
+ * draft (it does not compare this comment).
+ *
+ * Only `validate.ts` imports this schema. `validateMemory` runs it, and
+ * `defineMemory` (`define-memory.ts`) and `renderMemory` (`markdown.ts`)
+ * validate through `validateMemory`. `index.ts` re-exports it.
+ *
+ * What the codegen cannot express also lives in `validate.ts`: the
+ * root `anyOf` (canonical fields or the legacy id/name/type trio), the
+ * `$defs.lifetime` if/then rules (`until` needs `at`, `while` needs
+ * `anchor`), the unknown-key check on the root and `lifetime` objects
+ * (zod 4 drops it inside the `.and(...)` intersections below), and the
+ * AIP-72 conformance rules that apply to a single document.
+ */
+
+declare const memoryFrontmatterSchema: z.ZodIntersection<z.ZodObject<{
+    schema: z.ZodOptional<z.ZodLiteral<"memory/v1">>;
+    slug: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        feedback: "feedback";
+        project: "project";
+        reference: "reference";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    polarity: z.ZodOptional<z.ZodEnum<{
+        do: "do";
+        dont: "dont";
+    }>>;
+    lifetime: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        kind: z.ZodEnum<{
+            session: "session";
+            durable: "durable";
+            until: "until";
+            while: "while";
+        }>;
+        at: z.ZodOptional<z.ZodString>;
+        anchor: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                project: "project";
+                global: "global";
+                task: "task";
+                session: "session";
+                pr: "pr";
+                contact: "contact";
+                agent: "agent";
+            }>;
+            slug: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            number: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodIntersection<z.ZodAny, z.ZodAny>>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        superseded: "superseded";
+        archived: "archived";
+    }>>;
+    created: z.ZodOptional<z.ZodString>;
+    written: z.ZodOptional<z.ZodString>;
+    decidedBy: z.ZodOptional<z.ZodObject<{
+        rule: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+        quote: z.ZodOptional<z.ZodString>;
+        at: z.ZodOptional<z.ZodString>;
+        extractorVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    evidence: z.ZodOptional<z.ZodObject<{
+        sourceKind: z.ZodOptional<z.ZodString>;
+        trust: z.ZodOptional<z.ZodString>;
+        explicitness: z.ZodOptional<z.ZodString>;
+        corroborations: z.ZodOptional<z.ZodNumber>;
+        contradictsActive: z.ZodOptional<z.ZodBoolean>;
+        impact: z.ZodOptional<z.ZodString>;
+        lifetime: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+            kind: z.ZodEnum<{
+                session: "session";
+                durable: "durable";
+                until: "until";
+                while: "while";
+            }>;
+            at: z.ZodOptional<z.ZodString>;
+            anchor: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    project: "project";
+                    global: "global";
+                    task: "task";
+                    session: "session";
+                    pr: "pr";
+                    contact: "contact";
+                    agent: "agent";
+                }>;
+                slug: z.ZodOptional<z.ZodString>;
+                id: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                number: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodIntersection<z.ZodAny, z.ZodAny>>>;
+        anchorsResolved: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        ageHours: z.ZodOptional<z.ZodNumber>;
+        flags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    capture: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            live: "live";
+            batch: "batch";
+        }>>;
+        producer: z.ZodOptional<z.ZodString>;
+        capturedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    body: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodUnion<readonly [z.ZodAny, z.ZodAny]>>;
+
+/**
+ * @agentproto/memory: AIP-72 memory/v1 reference implementation.
+ *
+ * One small typed assertion (user, feedback, project, reference) about a
+ * principal or its work, with a lifecycle, stored as a markdown file
+ * with YAML frontmatter.
+ *
+ * Spec: https://agentproto.sh/docs/aip-72
+ *
+ * Authoring paths:
+ *   - TS:  `defineMemory({...})` -> frozen `MemoryHandle` (writer, canonical)
+ *   - MD:  `parseMemory(src)` -> `MemoryDocument`, then `validateMemory(doc)`
+ *   - out: `renderMemory(doc)` -> MEMORY.md text
+ */
+declare const SPEC_NAME: "memory/v1";
+declare const SPEC_VERSION: "1.0.0-alpha";
+
+export { MEMORY_STATUSES, MEMORY_TYPES, type MemoryAnchor, type MemoryCapture, type MemoryDecidedBy, type MemoryDefinition, type MemoryDocument, type MemoryEvidence, type MemoryFrontmatter, type MemoryHandle, type MemoryIssue, type MemoryLifetime, MemoryParseError, type MemoryProvenance, type MemoryStatus, type MemoryType, MemoryValidationError, type MemoryValidationResult, SPEC_NAME, SPEC_VERSION, type ValidateMemoryOptions, defineMemory, isAllowedStatusTransition, isInForce, memoryFrontmatterSchema, memoryStatus, parseMemory, renderMemory, validateMemory };

package/dist/index.mjs

@@ -0,0 +1,256 @@
+import { createDoctype } from '@agentproto/doctype';
+import { z } from 'zod';
+import { parseDocument, stringify } from 'yaml';
+
+/**
+ * @agentproto/memory
+ * AIP-72 memory/v1 `defineMemory` reference implementation.
+ */
+
+
+// src/errors.ts
+var MemoryValidationError = class extends Error {
+  /** Every error found, each naming its field path. */
+  issues;
+  /** Path of the first offending field (`""` for the whole document). */
+  field;
+  constructor(prefix, issues) {
+    super(
+      `${prefix}: ${issues.map((i) => `${i.path || "(document)"}: ${i.message}`).join("; ")}`
+    );
+    this.name = "MemoryValidationError";
+    this.issues = issues;
+    this.field = issues[0]?.path ?? "";
+  }
+};
+var MemoryParseError = class extends Error {
+  constructor(message) {
+    super(`parseMemory (AIP-72): ${message}`);
+    this.name = "MemoryParseError";
+  }
+};
+var memoryFrontmatterSchema = z.object({ "schema": z.literal("memory/v1").describe("Discriminator for a memory/v1 document. Optional only to tolerate legacy items written before this doctype existed; a canonical memory/v1 document MUST set it, and when present it MUST equal 'memory/v1'.").optional(), "slug": z.string().regex(new RegExp("^[a-z][a-z0-9-]*[a-z0-9]$")).min(2).max(96).describe("Stable kebab-case identifier (AIP-10 convention). Used as the item's path stem and cross-reference target.").optional(), "kind": z.string().regex(new RegExp("^[a-z][a-z0-9-]*$")).min(2).max(32).describe("Item kind (AIP-10 convention). Common values are the memory types: 'user', 'feedback', 'project', 'reference'.").optional(), "title": z.string().min(1).max(200).describe("Human-readable title (AIP-10 convention).").optional(), "updated_at": z.string().datetime({ offset: true }).describe("ISO 8601 timestamp of the last content write (AIP-10 convention). A writer MUST set it when it creates the item and when it changes any field other than `status`; a status-only lifecycle rewrite (to `superseded` or `archived`) MAY leave it unchanged.").optional(), "id": z.string().min(1).describe("Item identifier (e.g. 'mem_qc8f407g'). Legacy alias for the AIP-10 path stem; when the base fields are omitted it takes part in identifying the item.").optional(), "name": z.string().min(1).max(1e3).describe("Slugified name, distinct from `title`. Kept as a separate field so a legacy item round-trips without loss.").optional(), "type": z.enum(["user", "feedback", "project", "reference"]).describe("Memory type. The closed type set from the memory contract; `kind` is the AIP-10-aligned spelling of the same notion.").optional(), "description": z.string().max(4e3).describe("One-line human-readable summary, independent of the body.").optional(), "tags": z.array(z.string().min(1)).describe("Free-form labels. Scope anchors are carried here in their formatted form (e.g. 'global', 'project:fhcm', 'agent:assistant', 'pr:agentproto/ts#1858').").default([]), "polarity": z.enum(["do", "dont"]).describe("Feedback polarity. Present only on items of type 'feedback'.").optional(), "lifetime": z.object({ "kind": z.enum(["durable", "until", "while", "session"]).describe("Lifetime kind. 'durable' never expires; 'until' expires at `at`; 'while' lasts as long as `anchor` holds; 'session' lasts for the session."), "at": z.string().datetime({ offset: true }).describe("Expiry timestamp for kind 'until'.").optional(), "anchor": z.object({ "kind": z.enum(["global", "project", "task", "session", "pr", "contact", "agent"]).describe("Anchor kind. 'agent' extends the conversation-contract set for per-agent anchoring."), "slug": z.string().min(1).describe("Anchor target slug (project, contact, agent).").optional(), "id": z.string().min(1).describe("Anchor target id (task, session).").optional(), "repo": z.string().min(1).describe("Repository 'owner/name' for a pr anchor.").optional(), "number": z.number().int().gte(1).describe("Pull-request number for a pr anchor.").optional() }).strict().describe("Governing anchor for kind 'while'.").optional() }).strict().and(z.intersection(z.any(), z.any())).describe("How long the item stays valid. Typical values are { kind: 'durable' } or { kind: 'while', anchor: { \u2026 } }.").optional(), "status": z.enum(["active", "superseded", "archived"]).describe("Lifecycle status. A writer creates an item 'active'. 'superseded' means a newer item replaces it; 'archived' means it is retired without a replacement (decayed, or its anchor no longer resolves). Both are terminal: an item is marked, never erased. Absent means 'active'.").optional(), "created": z.string().datetime({ offset: true }).describe("Creation timestamp.").optional(), "written": z.string().datetime({ offset: true }).describe("Last-write timestamp. Mirrors the AIP-10 `updated_at`.").optional(), "decidedBy": z.object({ "rule": z.string().min(1).describe("Classifier rule that produced the item (e.g. 'lens-confident', 'brain-memory-file').").optional(), "source": z.string().min(1).describe("Where the deciding rule came from (e.g. 'builtin').").optional() }).strict().describe("Which classifier/rule decided the item's shape and status.").optional(), "provenance": z.object({ "source": z.string().min(1).describe("Provenance source class (e.g. 'brain-transcript', 'brain-memory-file', 'converse', 'task-close', 'recall-gap').").optional(), "sessionId": z.string().min(1).describe("Session the claim was observed in. Omitted, never empty, when the source has no session.").optional(), "ref": z.string().min(1).describe("Opaque reference into the source (message uuid, file path, ...). Omitted, never empty, when the source has none.").optional(), "quote": z.string().describe("Verbatim quote backing the claim.").optional(), "at": z.string().datetime({ offset: true }).describe("When the claim was observed.").optional(), "extractorVersion": z.string().min(1).describe("Identifier and version of the extractor that produced the claim (e.g. 'lens@3'), so a reader can tell items from different extractor generations apart.").optional() }).strict().describe("Origin of the item's claims.").optional(), "evidence": z.object({ "sourceKind": z.string().min(1).describe("Kind of source the evidence came from (e.g. 'brain-transcript', 'brain-memory-file').").optional(), "trust": z.string().min(1).describe("Trust class of the source (e.g. 'jeremy', 'internal').").optional(), "explicitness": z.string().min(1).describe("Whether the claim was stated outright or inferred (e.g. 'implicit', 'explicit').").optional(), "corroborations": z.number().int().gte(0).describe("Number of independent corroborating observations.").optional(), "contradictsActive": z.boolean().describe("True when this item contradicts an active item.").optional(), "impact": z.string().min(1).describe("Impact class of the item (e.g. 'low', 'high').").optional(), "lifetime": z.object({ "kind": z.enum(["durable", "until", "while", "session"]).describe("Lifetime kind. 'durable' never expires; 'until' expires at `at`; 'while' lasts as long as `anchor` holds; 'session' lasts for the session."), "at": z.string().datetime({ offset: true }).describe("Expiry timestamp for kind 'until'.").optional(), "anchor": z.object({ "kind": z.enum(["global", "project", "task", "session", "pr", "contact", "agent"]).describe("Anchor kind. 'agent' extends the conversation-contract set for per-agent anchoring."), "slug": z.string().min(1).describe("Anchor target slug (project, contact, agent).").optional(), "id": z.string().min(1).describe("Anchor target id (task, session).").optional(), "repo": z.string().min(1).describe("Repository 'owner/name' for a pr anchor.").optional(), "number": z.number().int().gte(1).describe("Pull-request number for a pr anchor.").optional() }).strict().describe("Governing anchor for kind 'while'.").optional() }).strict().and(z.intersection(z.any(), z.any())).describe("Lifetime as computed for the evidence pass.").optional(), "anchorsResolved": z.array(z.string().min(1)).describe("Resolved anchor labels in their formatted form (e.g. 'global', 'project:fhcm', 'pr:agentproto/ts#1858', 'session:sess_\u2026').").default([]), "ageHours": z.number().describe("Age of the evidence in hours (may be fractional or negative relative to the write clock).").optional(), "flags": z.array(z.string().min(1)).describe("Machine-stable flags raised during the evidence pass.").default([]) }).strict().describe("Trust/impact accounting captured at write time.").optional(), "capture": z.object({ "mode": z.enum(["live", "batch"]).describe("How the item was captured: 'live' during the session it describes, 'batch' by a later pass over stored transcripts or files.").optional(), "producer": z.string().min(1).describe("Who or what captured the item (e.g. a clerk lens, a migration, an importer). 'unknown' when the producer did not identify itself.").optional(), "capturedAt": z.string().datetime({ offset: true }).describe("ISO 8601 timestamp at which the source was captured or extracted.").optional() }).strict().describe("Who, what and how captured the item, kept apart from `provenance` (where the claim was observed).").optional(), "body": z.string().describe("Unrestricted markdown body of the MEMORY.md file. Not constrained by this schema.").optional() }).strict().and(z.union([z.any(), z.any()])).describe("Validates the YAML frontmatter of an AIP-72 memory/v1 item: one small typed assertion (user, feedback, project, reference) about a principal or its work, with a lifecycle. A third doctype in the memory layer: it neither absorbs nor replaces AIP-10 knowledge/v1 entries (curated, shareable wiki pages over immutable sources) nor AIP-11 lesson/v1 (distilled lessons from runs). A memory/v1 item carries the AIP-10 base fields (schema, slug, kind, title, updated_at); the remaining fields are the memory item shape and are OPTIONAL, so a writer that emits only the AIP-10 base fields and a writer that emits the full item both validate against the same schema. The markdown body (the `body` property) is unrestricted text.");
+
+// src/types.ts
+var MEMORY_TYPES = ["user", "feedback", "project", "reference"];
+var MEMORY_STATUSES = ["active", "superseded", "archived"];
+
+// src/validate.ts
+var CANONICAL_FIELDS = ["schema", "slug", "kind", "title", "updated_at"];
+var LEGACY_FIELDS = ["id", "name", "type"];
+var ROOT_KEYS = Object.keys(memoryFrontmatterSchema.def.left.shape);
+var LIFETIME_KEYS = Object.keys(
+  memoryFrontmatterSchema.def.left.shape.lifetime.unwrap().def.left.shape
+);
+function validateMemory(doc, opts = {}) {
+  const errors = [];
+  const warnings = [];
+  if (!isPlainObject(doc)) {
+    errors.push({ path: "", message: "must be an object", rule: "schema" });
+    return { ok: false, errors, warnings };
+  }
+  const parsed = memoryFrontmatterSchema.safeParse(doc);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      const base = issue.path.map(String);
+      if (issue.code === "unrecognized_keys") {
+        for (const key of issue.keys) {
+          errors.push({
+            path: [...base, key].join("."),
+            message: "unknown field",
+            rule: "schema"
+          });
+        }
+      } else {
+        errors.push({ path: base.join("."), message: issue.message, rule: "schema" });
+      }
+    }
+  }
+  checkUnknownKeys(doc, ROOT_KEYS, "", errors);
+  const missingCanonical = CANONICAL_FIELDS.filter((f) => doc[f] === void 0);
+  const hasLegacy = LEGACY_FIELDS.every((f) => doc[f] !== void 0);
+  if (missingCanonical.length > 0 && (opts.canonical || !hasLegacy)) {
+    for (const field of missingCanonical) {
+      errors.push({
+        path: field,
+        message: opts.canonical ? "required on an item a writer creates" : "required (or carry the legacy id, name, type trio)",
+        rule: opts.canonical ? "rule-1" : "schema"
+      });
+    }
+  }
+  checkLifetime(doc.lifetime, "lifetime", errors);
+  if (isPlainObject(doc.evidence)) {
+    checkLifetime(doc.evidence.lifetime, "evidence.lifetime", errors);
+  }
+  if (typeof doc.kind === "string" && !MEMORY_TYPES.includes(doc.kind)) {
+    errors.push({
+      path: "kind",
+      message: `must be one of ${MEMORY_TYPES.join(", ")}`,
+      rule: "section-2"
+    });
+  }
+  if (doc.kind !== void 0 && doc.type !== void 0 && doc.kind !== doc.type) {
+    errors.push({
+      path: "kind",
+      message: `must equal type ('${String(doc.type)}') when both are present`,
+      rule: "rule-2"
+    });
+  }
+  const { body: _body, ...frontmatter } = doc;
+  for (const path of emptyValuePaths(frontmatter, [])) {
+    if (errors.some((e) => e.path === path)) continue;
+    errors.push({ path, message: "empty value: omit the field instead", rule: "rule-4" });
+  }
+  const type = doc.type ?? doc.kind;
+  if (doc.polarity !== void 0 && type !== "feedback") {
+    errors.push({
+      path: "polarity",
+      message: "only allowed on an item whose type is 'feedback'",
+      rule: "rule-5"
+    });
+  }
+  const provenance = isPlainObject(doc.provenance) ? doc.provenance : {};
+  for (const field of ["source", "at"]) {
+    if (provenance[field] === void 0) {
+      warnings.push({
+        path: `provenance.${field}`,
+        message: "should be recorded",
+        rule: "rule-8"
+      });
+    }
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function checkLifetime(value, path, errors) {
+  if (!isPlainObject(value)) return;
+  checkUnknownKeys(value, LIFETIME_KEYS, path, errors);
+  if (value.kind === "until" && value.at === void 0) {
+    errors.push({ path: `${path}.at`, message: "required when kind is 'until'", rule: "schema" });
+  }
+  if (value.kind === "while" && value.anchor === void 0) {
+    errors.push({
+      path: `${path}.anchor`,
+      message: "required when kind is 'while'",
+      rule: "schema"
+    });
+  }
+}
+function checkUnknownKeys(value, known, path, errors) {
+  for (const key of Object.keys(value)) {
+    const keyPath = path ? `${path}.${key}` : key;
+    if (known.includes(key) || errors.some((e) => e.path === keyPath)) continue;
+    errors.push({ path: keyPath, message: "unknown field", rule: "schema" });
+  }
+}
+function emptyValuePaths(value, path) {
+  if (value === "") return [path.join(".")];
+  if (Array.isArray(value)) {
+    return value.flatMap((v, i) => emptyValuePaths(v, [...path, String(i)]));
+  }
+  if (!isPlainObject(value)) return [];
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+  if (entries.length === 0 && path.length > 0) return [path.join(".")];
+  return entries.flatMap(([k, v]) => emptyValuePaths(v, [...path, k]));
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/define-memory.ts
+var SLUG_PATTERN = /^[a-z][a-z0-9-]*[a-z0-9]$/;
+var constructMemory = createDoctype({
+  aip: 72,
+  name: "memory",
+  readIdentity: (def) => def.slug,
+  idPattern: SLUG_PATTERN,
+  // `description` is optional and up to 4000 chars; the schema checks it.
+  readDescription: false,
+  build(def) {
+    return deepFreeze({
+      ...structuredClone(def),
+      body: def.body ?? "",
+      status: def.status ?? "active"
+    });
+  }
+});
+function defineMemory(input) {
+  const result = validateMemory(input, { canonical: true });
+  if (!result.ok) {
+    throw new MemoryValidationError("defineMemory (AIP-72)", result.errors);
+  }
+  return constructMemory(input);
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null) {
+    for (const v of Object.values(value)) deepFreeze(v);
+    Object.freeze(value);
+  }
+  return value;
+}
+var FRONTMATTER_RE = /^---[ \t]*\r?\n(?:([\s\S]*?)\r?\n)?---[ \t]*(?:\r?\n|$)/;
+function parseMemory(markdown) {
+  const text = markdown.startsWith("\uFEFF") ? markdown.slice(1) : markdown;
+  const match = FRONTMATTER_RE.exec(text);
+  if (!match) {
+    throw new MemoryParseError("missing frontmatter: the file must open with a '---' fence");
+  }
+  const yamlDoc = parseDocument(match[1] ?? "", { version: "1.2", schema: "core" });
+  if (yamlDoc.errors.length > 0) {
+    throw new MemoryParseError(
+      `invalid YAML frontmatter: ${yamlDoc.errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  const data = yamlDoc.toJS();
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new MemoryParseError("frontmatter must be a YAML mapping");
+  }
+  if ("body" in data) {
+    throw new MemoryParseError("'body' is the markdown after the fence, not a frontmatter key");
+  }
+  let body = text.slice(match[0].length);
+  if (body.startsWith("\r\n")) body = body.slice(2);
+  else if (body.startsWith("\n")) body = body.slice(1);
+  return { ...data, body };
+}
+function renderMemory(doc) {
+  const result = validateMemory(doc);
+  if (!result.ok) {
+    throw new MemoryValidationError("renderMemory (AIP-72)", result.errors);
+  }
+  const { body, ...frontmatter } = doc;
+  const yamlText = stringify(frontmatter, {
+    version: "1.2",
+    defaultStringType: "QUOTE_DOUBLE",
+    defaultKeyType: "PLAIN",
+    lineWidth: 0
+  });
+  return `---
+${yamlText}---
+${body ? `
+${body}` : ""}`;
+}
+
+// src/lifecycle.ts
+function memoryStatus(doc) {
+  return doc.status ?? "active";
+}
+function isAllowedStatusTransition(from, to) {
+  const current = from ?? "active";
+  return current === to || current === "active";
+}
+function isInForce(doc, now = /* @__PURE__ */ new Date()) {
+  if (memoryStatus(doc) !== "active") return false;
+  const lifetime = doc.lifetime;
+  if (lifetime?.kind === "until" && lifetime.at !== void 0) {
+    return Date.parse(lifetime.at) > now.getTime();
+  }
+  return true;
+}
+
+// src/index.ts
+var SPEC_NAME = "memory/v1";
+var SPEC_VERSION = "1.0.0-alpha";
+
+export { MEMORY_STATUSES, MEMORY_TYPES, MemoryParseError, MemoryValidationError, SPEC_NAME, SPEC_VERSION, defineMemory, isAllowedStatusTransition, isInForce, memoryFrontmatterSchema, memoryStatus, parseMemory, renderMemory, validateMemory };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/schema.ts","../src/types.ts","../src/validate.ts","../src/define-memory.ts","../src/markdown.ts","../src/lifecycle.ts","../src/index.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["import type { MemoryIssue } from \"./types.js\"\n\n/** Thrown by `defineMemory` and `renderMemory` on an invalid item. */\nexport class MemoryValidationError extends Error {\n  /** Every error found, each naming its field path. */\n  readonly issues: readonly MemoryIssue[]\n  /** Path of the first offending field (`\"\"` for the whole document). */\n  readonly field: string\n\n  constructor(prefix: string, issues: readonly MemoryIssue[]) {\n    super(\n      `${prefix}: ${issues\n        .map((i) => `${i.path || \"(document)\"}: ${i.message}`)\n        .join(\"; \")}`,\n    )\n    this.name = \"MemoryValidationError\"\n    this.issues = issues\n    this.field = issues[0]?.path ?? \"\"\n  }\n}\n\n/** Thrown by `parseMemory` when the markdown has no readable frontmatter. */\nexport class MemoryParseError extends Error {\n  constructor(message: string) {\n    super(`parseMemory (AIP-72): ${message}`)\n    this.name = \"MemoryParseError\"\n  }\n}\n","/**\n * AIP-72 memory/v1 frontmatter zod schema.\n *\n * Codegen output of `scripts/scaffold-aip.mjs --aip 72 --slug memory\n * --doctype MEMORY --schema-only --inline-refs` over\n * `specs/resources/aip-72/draft/MEMORY.schema.json`. Do not edit the code\n * below by hand: change the JSON draft, then regenerate.\n * `scripts/check-spec-drift.mjs` fails CI when the code drifts from the\n * draft (it does not compare this comment).\n *\n * Only `validate.ts` imports this schema. `validateMemory` runs it, and\n * `defineMemory` (`define-memory.ts`) and `renderMemory` (`markdown.ts`)\n * validate through `validateMemory`. `index.ts` re-exports it.\n *\n * What the codegen cannot express also lives in `validate.ts`: the\n * root `anyOf` (canonical fields or the legacy id/name/type trio), the\n * `$defs.lifetime` if/then rules (`until` needs `at`, `while` needs\n * `anchor`), the unknown-key check on the root and `lifetime` objects\n * (zod 4 drops it inside the `.and(...)` intersections below), and the\n * AIP-72 conformance rules that apply to a single document.\n */\n\nimport { z } from \"zod\"\n\nexport const memoryFrontmatterSchema = z.object({ \"schema\": z.literal(\"memory/v1\").describe(\"Discriminator for a memory/v1 document. Optional only to tolerate legacy items written before this doctype existed; a canonical memory/v1 document MUST set it, and when present it MUST equal 'memory/v1'.\").optional(), \"slug\": z.string().regex(new RegExp(\"^[a-z][a-z0-9-]*[a-z0-9]$\")).min(2).max(96).describe(\"Stable kebab-case identifier (AIP-10 convention). Used as the item's path stem and cross-reference target.\").optional(), \"kind\": z.string().regex(new RegExp(\"^[a-z][a-z0-9-]*$\")).min(2).max(32).describe(\"Item kind (AIP-10 convention). Common values are the memory types: 'user', 'feedback', 'project', 'reference'.\").optional(), \"title\": z.string().min(1).max(200).describe(\"Human-readable title (AIP-10 convention).\").optional(), \"updated_at\": z.string().datetime({ offset: true }).describe(\"ISO 8601 timestamp of the last content write (AIP-10 convention). A writer MUST set it when it creates the item and when it changes any field other than `status`; a status-only lifecycle rewrite (to `superseded` or `archived`) MAY leave it unchanged.\").optional(), \"id\": z.string().min(1).describe(\"Item identifier (e.g. 'mem_qc8f407g'). Legacy alias for the AIP-10 path stem; when the base fields are omitted it takes part in identifying the item.\").optional(), \"name\": z.string().min(1).max(1000).describe(\"Slugified name, distinct from `title`. Kept as a separate field so a legacy item round-trips without loss.\").optional(), \"type\": z.enum([\"user\",\"feedback\",\"project\",\"reference\"]).describe(\"Memory type. The closed type set from the memory contract; `kind` is the AIP-10-aligned spelling of the same notion.\").optional(), \"description\": z.string().max(4000).describe(\"One-line human-readable summary, independent of the body.\").optional(), \"tags\": z.array(z.string().min(1)).describe(\"Free-form labels. Scope anchors are carried here in their formatted form (e.g. 'global', 'project:fhcm', 'agent:assistant', 'pr:agentproto/ts#1858').\").default([] as never), \"polarity\": z.enum([\"do\",\"dont\"]).describe(\"Feedback polarity. Present only on items of type 'feedback'.\").optional(), \"lifetime\": z.object({ \"kind\": z.enum([\"durable\",\"until\",\"while\",\"session\"]).describe(\"Lifetime kind. 'durable' never expires; 'until' expires at `at`; 'while' lasts as long as `anchor` holds; 'session' lasts for the session.\"), \"at\": z.string().datetime({ offset: true }).describe(\"Expiry timestamp for kind 'until'.\").optional(), \"anchor\": z.object({ \"kind\": z.enum([\"global\",\"project\",\"task\",\"session\",\"pr\",\"contact\",\"agent\"]).describe(\"Anchor kind. 'agent' extends the conversation-contract set for per-agent anchoring.\"), \"slug\": z.string().min(1).describe(\"Anchor target slug (project, contact, agent).\").optional(), \"id\": z.string().min(1).describe(\"Anchor target id (task, session).\").optional(), \"repo\": z.string().min(1).describe(\"Repository 'owner/name' for a pr anchor.\").optional(), \"number\": z.number().int().gte(1).describe(\"Pull-request number for a pr anchor.\").optional() }).strict().describe(\"Governing anchor for kind 'while'.\").optional() }).strict().and(z.intersection(z.any(), z.any())).describe(\"How long the item stays valid. Typical values are { kind: 'durable' } or { kind: 'while', anchor: { … } }.\").optional(), \"status\": z.enum([\"active\",\"superseded\",\"archived\"]).describe(\"Lifecycle status. A writer creates an item 'active'. 'superseded' means a newer item replaces it; 'archived' means it is retired without a replacement (decayed, or its anchor no longer resolves). Both are terminal: an item is marked, never erased. Absent means 'active'.\").optional(), \"created\": z.string().datetime({ offset: true }).describe(\"Creation timestamp.\").optional(), \"written\": z.string().datetime({ offset: true }).describe(\"Last-write timestamp. Mirrors the AIP-10 `updated_at`.\").optional(), \"decidedBy\": z.object({ \"rule\": z.string().min(1).describe(\"Classifier rule that produced the item (e.g. 'lens-confident', 'brain-memory-file').\").optional(), \"source\": z.string().min(1).describe(\"Where the deciding rule came from (e.g. 'builtin').\").optional() }).strict().describe(\"Which classifier/rule decided the item's shape and status.\").optional(), \"provenance\": z.object({ \"source\": z.string().min(1).describe(\"Provenance source class (e.g. 'brain-transcript', 'brain-memory-file', 'converse', 'task-close', 'recall-gap').\").optional(), \"sessionId\": z.string().min(1).describe(\"Session the claim was observed in. Omitted, never empty, when the source has no session.\").optional(), \"ref\": z.string().min(1).describe(\"Opaque reference into the source (message uuid, file path, ...). Omitted, never empty, when the source has none.\").optional(), \"quote\": z.string().describe(\"Verbatim quote backing the claim.\").optional(), \"at\": z.string().datetime({ offset: true }).describe(\"When the claim was observed.\").optional(), \"extractorVersion\": z.string().min(1).describe(\"Identifier and version of the extractor that produced the claim (e.g. 'lens@3'), so a reader can tell items from different extractor generations apart.\").optional() }).strict().describe(\"Origin of the item's claims.\").optional(), \"evidence\": z.object({ \"sourceKind\": z.string().min(1).describe(\"Kind of source the evidence came from (e.g. 'brain-transcript', 'brain-memory-file').\").optional(), \"trust\": z.string().min(1).describe(\"Trust class of the source (e.g. 'jeremy', 'internal').\").optional(), \"explicitness\": z.string().min(1).describe(\"Whether the claim was stated outright or inferred (e.g. 'implicit', 'explicit').\").optional(), \"corroborations\": z.number().int().gte(0).describe(\"Number of independent corroborating observations.\").optional(), \"contradictsActive\": z.boolean().describe(\"True when this item contradicts an active item.\").optional(), \"impact\": z.string().min(1).describe(\"Impact class of the item (e.g. 'low', 'high').\").optional(), \"lifetime\": z.object({ \"kind\": z.enum([\"durable\",\"until\",\"while\",\"session\"]).describe(\"Lifetime kind. 'durable' never expires; 'until' expires at `at`; 'while' lasts as long as `anchor` holds; 'session' lasts for the session.\"), \"at\": z.string().datetime({ offset: true }).describe(\"Expiry timestamp for kind 'until'.\").optional(), \"anchor\": z.object({ \"kind\": z.enum([\"global\",\"project\",\"task\",\"session\",\"pr\",\"contact\",\"agent\"]).describe(\"Anchor kind. 'agent' extends the conversation-contract set for per-agent anchoring.\"), \"slug\": z.string().min(1).describe(\"Anchor target slug (project, contact, agent).\").optional(), \"id\": z.string().min(1).describe(\"Anchor target id (task, session).\").optional(), \"repo\": z.string().min(1).describe(\"Repository 'owner/name' for a pr anchor.\").optional(), \"number\": z.number().int().gte(1).describe(\"Pull-request number for a pr anchor.\").optional() }).strict().describe(\"Governing anchor for kind 'while'.\").optional() }).strict().and(z.intersection(z.any(), z.any())).describe(\"Lifetime as computed for the evidence pass.\").optional(), \"anchorsResolved\": z.array(z.string().min(1)).describe(\"Resolved anchor labels in their formatted form (e.g. 'global', 'project:fhcm', 'pr:agentproto/ts#1858', 'session:sess_…').\").default([] as never), \"ageHours\": z.number().describe(\"Age of the evidence in hours (may be fractional or negative relative to the write clock).\").optional(), \"flags\": z.array(z.string().min(1)).describe(\"Machine-stable flags raised during the evidence pass.\").default([] as never) }).strict().describe(\"Trust/impact accounting captured at write time.\").optional(), \"capture\": z.object({ \"mode\": z.enum([\"live\",\"batch\"]).describe(\"How the item was captured: 'live' during the session it describes, 'batch' by a later pass over stored transcripts or files.\").optional(), \"producer\": z.string().min(1).describe(\"Who or what captured the item (e.g. a clerk lens, a migration, an importer). 'unknown' when the producer did not identify itself.\").optional(), \"capturedAt\": z.string().datetime({ offset: true }).describe(\"ISO 8601 timestamp at which the source was captured or extracted.\").optional() }).strict().describe(\"Who, what and how captured the item, kept apart from `provenance` (where the claim was observed).\").optional(), \"body\": z.string().describe(\"Unrestricted markdown body of the MEMORY.md file. Not constrained by this schema.\").optional() }).strict().and(z.union([z.any(), z.any()])).describe(\"Validates the YAML frontmatter of an AIP-72 memory/v1 item: one small typed assertion (user, feedback, project, reference) about a principal or its work, with a lifecycle. A third doctype in the memory layer: it neither absorbs nor replaces AIP-10 knowledge/v1 entries (curated, shareable wiki pages over immutable sources) nor AIP-11 lesson/v1 (distilled lessons from runs). A memory/v1 item carries the AIP-10 base fields (schema, slug, kind, title, updated_at); the remaining fields are the memory item shape and are OPTIONAL, so a writer that emits only the AIP-10 base fields and a writer that emits the full item both validate against the same schema. The markdown body (the `body` property) is unrestricted text.\")\n\nexport type MemoryFrontmatter = z.infer<typeof memoryFrontmatterSchema>\n","/**\n * AIP-72 memory/v1 document types.\n *\n * Hand-tuned on top of the shape `json-schema-to-typescript` generates\n * from `resources/aip-72/draft/MEMORY.schema.json`: the `$defs` get\n * `Memory*` names, and the document carries its markdown `body` as a\n * required string (the schema's `body` property stands for the text\n * after the closing frontmatter fence).\n */\n\nexport const MEMORY_TYPES = [\"user\", \"feedback\", \"project\", \"reference\"] as const\n/** The closed memory type set (`type`, and `kind` on a memory/v1 item). */\nexport type MemoryType = (typeof MEMORY_TYPES)[number]\n\nexport const MEMORY_STATUSES = [\"active\", \"superseded\", \"archived\"] as const\n/** Lifecycle status. Absent means `active` (AIP-72 rule 9). */\nexport type MemoryStatus = (typeof MEMORY_STATUSES)[number]\n\nexport interface MemoryAnchor {\n  kind: \"global\" | \"project\" | \"task\" | \"session\" | \"pr\" | \"contact\" | \"agent\"\n  /** Anchor target slug (project, contact, agent). */\n  slug?: string\n  /** Anchor target id (task, session). */\n  id?: string\n  /** Repository `owner/name` for a pr anchor. */\n  repo?: string\n  /** Pull-request number for a pr anchor. */\n  number?: number\n}\n\nexport interface MemoryLifetime {\n  kind: \"durable\" | \"until\" | \"while\" | \"session\"\n  /** Expiry timestamp, REQUIRED for kind `until`. */\n  at?: string\n  /** Governing anchor, REQUIRED for kind `while`. */\n  anchor?: MemoryAnchor\n}\n\nexport interface MemoryDecidedBy {\n  rule?: string\n  source?: string\n}\n\nexport interface MemoryProvenance {\n  source?: string\n  /** Omitted, never empty, when the source has no session. */\n  sessionId?: string\n  /** Omitted, never empty, when the source has none. */\n  ref?: string\n  quote?: string\n  at?: string\n  extractorVersion?: string\n}\n\nexport interface MemoryCapture {\n  mode?: \"live\" | \"batch\"\n  producer?: string\n  capturedAt?: string\n}\n\nexport interface MemoryEvidence {\n  sourceKind?: string\n  trust?: string\n  explicitness?: string\n  corroborations?: number\n  contradictsActive?: boolean\n  impact?: string\n  lifetime?: MemoryLifetime\n  anchorsResolved?: string[]\n  ageHours?: number\n  flags?: string[]\n}\n\n/**\n * The YAML frontmatter of a memory/v1 item. Every field is optional at\n * the type level: the schema accepts either the canonical AIP-10 base\n * fields (`schema`, `slug`, `kind`, `title`, `updated_at`) or the legacy\n * trio (`id`, `name`, `type`), which `validateMemory` checks.\n */\nexport interface MemoryFrontmatter {\n  schema?: \"memory/v1\"\n  slug?: string\n  kind?: string\n  title?: string\n  updated_at?: string\n  id?: string\n  name?: string\n  type?: MemoryType\n  description?: string\n  tags?: string[]\n  polarity?: \"do\" | \"dont\"\n  lifetime?: MemoryLifetime\n  status?: MemoryStatus\n  created?: string\n  written?: string\n  decidedBy?: MemoryDecidedBy\n  provenance?: MemoryProvenance\n  evidence?: MemoryEvidence\n  capture?: MemoryCapture\n}\n\n/** One memory/v1 item: frontmatter fields plus the markdown body. */\nexport interface MemoryDocument extends MemoryFrontmatter {\n  body: string\n}\n\n/** `defineMemory` input: `body` may be omitted for an item with no prose. */\nexport type MemoryDefinition = MemoryFrontmatter & { body?: string }\n\n/** The frozen item `defineMemory` returns, with `status` made explicit. */\nexport type MemoryHandle = Readonly<MemoryDocument & { status: MemoryStatus }>\n\n/**\n * One validation finding. `path` is the dot path of the offending field\n * (`provenance.sessionId`, `lifetime.at`, `tags.0`), `\"\"` for the whole\n * document. `rule` is `schema` for a MEMORY.schema.json constraint,\n * `section-2` for the memory/v1 `kind` set, or `rule-<n>` for AIP-72\n * conformance rule n.\n */\nexport interface MemoryIssue {\n  path: string\n  message: string\n  rule: string\n}\n\nexport interface MemoryValidationResult {\n  ok: boolean\n  errors: MemoryIssue[]\n  /** SHOULD-level findings (rule 8). Never make `ok` false. */\n  warnings: MemoryIssue[]\n}\n","import { memoryFrontmatterSchema } from \"./schema.js\"\nimport {\n  MEMORY_TYPES,\n  type MemoryIssue,\n  type MemoryValidationResult,\n} from \"./types.js\"\n\nexport interface ValidateMemoryOptions {\n  /**\n   * Require the canonical fields (`schema`, `slug`, `kind`, `title`,\n   * `updated_at`), as rule 1 asks of a writer creating an item. Off by\n   * default: a reader MUST accept legacy items (rule 9).\n   */\n  canonical?: boolean\n}\n\nconst CANONICAL_FIELDS = [\"schema\", \"slug\", \"kind\", \"title\", \"updated_at\"] as const\nconst LEGACY_FIELDS = [\"id\", \"name\", \"type\"] as const\n\n// The codegen wraps the root and `lifetime` objects in `.strict().and(...)`\n// (for the `anyOf` / `allOf` branches), and zod 4 does not report a key\n// unknown to a strict object inside an intersection. Check those two\n// key sets here, read from the generated schema itself.\nconst ROOT_KEYS = Object.keys(memoryFrontmatterSchema.def.left.shape)\nconst LIFETIME_KEYS = Object.keys(\n  memoryFrontmatterSchema.def.left.shape.lifetime.unwrap().def.left.shape,\n)\n\n/**\n * Validate one memory/v1 document (frontmatter fields plus `body`).\n *\n * Runs MEMORY.schema.json (through the generated zod, plus the\n * `anyOf` and lifetime `if/then` branches the codegen cannot express)\n * and the AIP-72 conformance rules checkable on a single document:\n * section 2 (`kind` set), rules 1, 2, 4 and 5 as errors, rule 8 as\n * warnings. Rules 6 and 7 compare two versions of an item and belong to\n * the store; `isAllowedStatusTransition` covers rule 7's table.\n */\nexport function validateMemory(\n  doc: unknown,\n  opts: ValidateMemoryOptions = {},\n): MemoryValidationResult {\n  const errors: MemoryIssue[] = []\n  const warnings: MemoryIssue[] = []\n  if (!isPlainObject(doc)) {\n    errors.push({ path: \"\", message: \"must be an object\", rule: \"schema\" })\n    return { ok: false, errors, warnings }\n  }\n\n  const parsed = memoryFrontmatterSchema.safeParse(doc)\n  if (!parsed.success) {\n    for (const issue of parsed.error.issues) {\n      const base = issue.path.map(String)\n      if (issue.code === \"unrecognized_keys\") {\n        for (const key of issue.keys) {\n          errors.push({\n            path: [...base, key].join(\".\"),\n            message: \"unknown field\",\n            rule: \"schema\",\n          })\n        }\n      } else {\n        errors.push({ path: base.join(\".\"), message: issue.message, rule: \"schema\" })\n      }\n    }\n  }\n\n  checkUnknownKeys(doc, ROOT_KEYS, \"\", errors)\n\n  // anyOf: canonical base fields, or the legacy id/name/type trio.\n  const missingCanonical = CANONICAL_FIELDS.filter((f) => doc[f] === undefined)\n  const hasLegacy = LEGACY_FIELDS.every((f) => doc[f] !== undefined)\n  if (missingCanonical.length > 0 && (opts.canonical || !hasLegacy)) {\n    for (const field of missingCanonical) {\n      errors.push({\n        path: field,\n        message: opts.canonical\n          ? \"required on an item a writer creates\"\n          : \"required (or carry the legacy id, name, type trio)\",\n        rule: opts.canonical ? \"rule-1\" : \"schema\",\n      })\n    }\n  }\n\n  // $defs.lifetime allOf: `until` needs `at`, `while` needs `anchor`.\n  checkLifetime(doc.lifetime, \"lifetime\", errors)\n  if (isPlainObject(doc.evidence)) {\n    checkLifetime(doc.evidence.lifetime, \"evidence.lifetime\", errors)\n  }\n\n  // Section 2: on a memory/v1 item `kind` is one of the memory types.\n  if (\n    typeof doc.kind === \"string\" &&\n    !(MEMORY_TYPES as readonly string[]).includes(doc.kind)\n  ) {\n    errors.push({\n      path: \"kind\",\n      message: `must be one of ${MEMORY_TYPES.join(\", \")}`,\n      rule: \"section-2\",\n    })\n  }\n\n  // Rule 2: kind and type agree when both are present.\n  if (doc.kind !== undefined && doc.type !== undefined && doc.kind !== doc.type) {\n    errors.push({\n      path: \"kind\",\n      message: `must equal type ('${String(doc.type)}') when both are present`,\n      rule: \"rule-2\",\n    })\n  }\n\n  // Rule 4: an optional field with no value is omitted, never empty.\n  const { body: _body, ...frontmatter } = doc\n  for (const path of emptyValuePaths(frontmatter, [])) {\n    if (errors.some((e) => e.path === path)) continue\n    errors.push({ path, message: \"empty value: omit the field instead\", rule: \"rule-4\" })\n  }\n\n  // Rule 5: polarity only on feedback items.\n  const type = doc.type ?? doc.kind\n  if (doc.polarity !== undefined && type !== \"feedback\") {\n    errors.push({\n      path: \"polarity\",\n      message: \"only allowed on an item whose type is 'feedback'\",\n      rule: \"rule-5\",\n    })\n  }\n\n  // Rule 8 (SHOULD): record where and when the claim was observed.\n  const provenance = isPlainObject(doc.provenance) ? doc.provenance : {}\n  for (const field of [\"source\", \"at\"] as const) {\n    if (provenance[field] === undefined) {\n      warnings.push({\n        path: `provenance.${field}`,\n        message: \"should be recorded\",\n        rule: \"rule-8\",\n      })\n    }\n  }\n\n  return { ok: errors.length === 0, errors, warnings }\n}\n\nfunction checkLifetime(value: unknown, path: string, errors: MemoryIssue[]): void {\n  if (!isPlainObject(value)) return\n  checkUnknownKeys(value, LIFETIME_KEYS, path, errors)\n  if (value.kind === \"until\" && value.at === undefined) {\n    errors.push({ path: `${path}.at`, message: \"required when kind is 'until'\", rule: \"schema\" })\n  }\n  if (value.kind === \"while\" && value.anchor === undefined) {\n    errors.push({\n      path: `${path}.anchor`,\n      message: \"required when kind is 'while'\",\n      rule: \"schema\",\n    })\n  }\n}\n\nfunction checkUnknownKeys(\n  value: Record<string, unknown>,\n  known: readonly string[],\n  path: string,\n  errors: MemoryIssue[],\n): void {\n  for (const key of Object.keys(value)) {\n    const keyPath = path ? `${path}.${key}` : key\n    if (known.includes(key) || errors.some((e) => e.path === keyPath)) continue\n    errors.push({ path: keyPath, message: \"unknown field\", rule: \"schema\" })\n  }\n}\n\n/** Paths of empty strings and empty objects below the document root. */\nfunction emptyValuePaths(value: unknown, path: string[]): string[] {\n  if (value === \"\") return [path.join(\".\")]\n  if (Array.isArray(value)) {\n    return value.flatMap((v, i) => emptyValuePaths(v, [...path, String(i)]))\n  }\n  if (!isPlainObject(value)) return []\n  const entries = Object.entries(value).filter(([, v]) => v !== undefined)\n  if (entries.length === 0 && path.length > 0) return [path.join(\".\")]\n  return entries.flatMap(([k, v]) => emptyValuePaths(v, [...path, k]))\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value)\n}\n","import { createDoctype } from \"@agentproto/doctype\"\nimport { MemoryValidationError } from \"./errors.js\"\nimport type { MemoryDefinition, MemoryHandle } from \"./types.js\"\nimport { validateMemory } from \"./validate.js\"\n\nconst SLUG_PATTERN = /^[a-z][a-z0-9-]*[a-z0-9]$/\n\nconst constructMemory = createDoctype<MemoryDefinition, MemoryHandle>({\n  aip: 72,\n  name: \"memory\",\n  readIdentity: (def) => def.slug as string,\n  idPattern: SLUG_PATTERN,\n  // `description` is optional and up to 4000 chars; the schema checks it.\n  readDescription: false,\n  build(def) {\n    return deepFreeze({\n      ...structuredClone(def),\n      body: def.body ?? \"\",\n      status: def.status ?? \"active\",\n    }) as MemoryHandle\n  },\n})\n\n/**\n * AIP-72 reference implementation of `defineMemory`: the writer path.\n *\n * Validates in canonical mode (rule 1: a writer sets `schema`, `slug`,\n * `kind`, `title`, `updated_at` on every item it creates) and throws a\n * `MemoryValidationError` whose `field` / `issues` name the offending\n * field paths. Only two values are filled in: `status` becomes `active`\n * when absent (section 3: a writer creates an item `active`), and an\n * absent `body` becomes `\"\"`. Nothing else is defaulted; in particular\n * `tags` is not set to `[]`, since rule 4 omits an empty optional field.\n *\n * Built on `createDoctype` for the shared slug check and top-level\n * freeze; the handle is frozen deeply and does not alias the input.\n */\nexport function defineMemory(input: MemoryDefinition): MemoryHandle {\n  const result = validateMemory(input, { canonical: true })\n  if (!result.ok) {\n    throw new MemoryValidationError(\"defineMemory (AIP-72)\", result.errors)\n  }\n  return constructMemory(input)\n}\n\nfunction deepFreeze<T>(value: T): T {\n  if (typeof value === \"object\" && value !== null) {\n    for (const v of Object.values(value)) deepFreeze(v)\n    Object.freeze(value)\n  }\n  return value\n}\n","import { parseDocument, stringify } from \"yaml\"\nimport { MemoryParseError, MemoryValidationError } from \"./errors.js\"\nimport type { MemoryDocument } from \"./types.js\"\nimport { validateMemory } from \"./validate.js\"\n\nconst FRONTMATTER_RE = /^---[ \\t]*\\r?\\n(?:([\\s\\S]*?)\\r?\\n)?---[ \\t]*(?:\\r?\\n|$)/\n\n/**\n * Split a MEMORY.md file into its frontmatter fields and `body`.\n *\n * The frontmatter is read as YAML 1.2 core schema, so a date-time stays\n * a string and an unquoted `true`, `null` or `2026` in a string field\n * reaches `validateMemory` as a non-string and fails there (rule 3).\n * This only parses: it does not validate, so a reader can still load an\n * item it will then inspect. The body is free (rule 12): one blank line\n * after the closing fence is the separator, everything after it is kept\n * byte for byte.\n */\nexport function parseMemory(markdown: string): MemoryDocument {\n  const text = markdown.startsWith(\"\") ? markdown.slice(1) : markdown\n  const match = FRONTMATTER_RE.exec(text)\n  if (!match) {\n    throw new MemoryParseError(\"missing frontmatter: the file must open with a '---' fence\")\n  }\n  const yamlDoc = parseDocument(match[1] ?? \"\", { version: \"1.2\", schema: \"core\" })\n  if (yamlDoc.errors.length > 0) {\n    throw new MemoryParseError(\n      `invalid YAML frontmatter: ${yamlDoc.errors.map((e) => e.message).join(\"; \")}`,\n    )\n  }\n  const data: unknown = yamlDoc.toJS()\n  if (typeof data !== \"object\" || data === null || Array.isArray(data)) {\n    throw new MemoryParseError(\"frontmatter must be a YAML mapping\")\n  }\n  if (\"body\" in data) {\n    throw new MemoryParseError(\"'body' is the markdown after the fence, not a frontmatter key\")\n  }\n  let body = text.slice(match[0].length)\n  if (body.startsWith(\"\\r\\n\")) body = body.slice(2)\n  else if (body.startsWith(\"\\n\")) body = body.slice(1)\n  return { ...(data as Omit<MemoryDocument, \"body\">), body }\n}\n\n/**\n * Render a memory/v1 document as MEMORY.md. Throws a\n * `MemoryValidationError` if the document does not validate.\n *\n * Every string value is double-quoted, so a YAML 1.1 or 1.2 reader\n * reads it back as a string (rule 3); undefined fields are omitted\n * (rule 4); key order is the document's own, so a status-only rewrite\n * changes only the `status` line (rule 6). `parseMemory(renderMemory(d))`\n * deep-equals `d`.\n */\nexport function renderMemory(doc: MemoryDocument): string {\n  const result = validateMemory(doc)\n  if (!result.ok) {\n    throw new MemoryValidationError(\"renderMemory (AIP-72)\", result.errors)\n  }\n  const { body, ...frontmatter } = doc\n  const yamlText = stringify(frontmatter, {\n    version: \"1.2\",\n    defaultStringType: \"QUOTE_DOUBLE\",\n    defaultKeyType: \"PLAIN\",\n    lineWidth: 0,\n  })\n  return `---\\n${yamlText}---\\n${body ? `\\n${body}` : \"\"}`\n}\n","import type { MemoryFrontmatter, MemoryStatus } from \"./types.js\"\n\n/** The item's status, reading an absent `status` as `active` (rule 9). */\nexport function memoryStatus(doc: Pick<MemoryFrontmatter, \"status\">): MemoryStatus {\n  return doc.status ?? \"active\"\n}\n\n/**\n * Rule 7: a writer only moves `status` from `active` (or absent) to\n * `superseded` or `archived`, and never out of either. Rewriting the\n * same status is not a transition and is allowed.\n */\nexport function isAllowedStatusTransition(\n  from: MemoryStatus | undefined,\n  to: MemoryStatus,\n): boolean {\n  const current = from ?? \"active\"\n  return current === to || current === \"active\"\n}\n\n/**\n * Whether a reader may present the item as in force at `now`.\n *\n * Rule 10: a `superseded` or `archived` item is not. Rule 11: an\n * `until` lifetime past its `at` is not. A `while` anchor or a\n * `session` lifetime needs context outside the document (does the\n * anchor still hold, which session is current), so this check treats\n * them as holding; the store that has that context narrows further.\n */\nexport function isInForce(\n  doc: Pick<MemoryFrontmatter, \"status\" | \"lifetime\">,\n  now: Date = new Date(),\n): boolean {\n  if (memoryStatus(doc) !== \"active\") return false\n  const lifetime = doc.lifetime\n  if (lifetime?.kind === \"until\" && lifetime.at !== undefined) {\n    return Date.parse(lifetime.at) > now.getTime()\n  }\n  return true\n}\n","/**\n * @agentproto/memory: AIP-72 memory/v1 reference implementation.\n *\n * One small typed assertion (user, feedback, project, reference) about a\n * principal or its work, with a lifecycle, stored as a markdown file\n * with YAML frontmatter.\n *\n * Spec: https://agentproto.sh/docs/aip-72\n *\n * Authoring paths:\n *   - TS:  `defineMemory({...})` -> frozen `MemoryHandle` (writer, canonical)\n *   - MD:  `parseMemory(src)` -> `MemoryDocument`, then `validateMemory(doc)`\n *   - out: `renderMemory(doc)` -> MEMORY.md text\n */\n\nexport const SPEC_NAME = \"memory/v1\" as const\nexport const SPEC_VERSION = \"1.0.0-alpha\" as const\n\nexport { defineMemory } from \"./define-memory.js\"\nexport { validateMemory, type ValidateMemoryOptions } from \"./validate.js\"\nexport { parseMemory, renderMemory } from \"./markdown.js\"\nexport { isAllowedStatusTransition, isInForce, memoryStatus } from \"./lifecycle.js\"\nexport { MemoryParseError, MemoryValidationError } from \"./errors.js\"\nexport { memoryFrontmatterSchema } from \"./schema.js\"\nexport {\n  MEMORY_STATUSES,\n  MEMORY_TYPES,\n  type MemoryAnchor,\n  type MemoryCapture,\n  type MemoryDecidedBy,\n  type MemoryDefinition,\n  type MemoryDocument,\n  type MemoryEvidence,\n  type MemoryFrontmatter,\n  type MemoryHandle,\n  type MemoryIssue,\n  type MemoryLifetime,\n  type MemoryProvenance,\n  type MemoryStatus,\n  type MemoryType,\n  type MemoryValidationResult,\n} from \"./types.js\"\n"]}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@agentproto/memory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "@agentproto/memory: AIP-72 memory/v1 reference implementation. Define, validate, parse and render MEMORY.md items: one small typed assertion (user, feedback, project, reference) about a principal or its work, with a lifecycle.",
+  "keywords": [
+    "agentproto",
+    "aip-72",
+    "memory",
+    "defineMemory",
+    "open-standard",
+    "agentic"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-72",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/memory"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yaml": "^2.9.1",
+    "zod": "^4.6.7",
+    "@agentproto/doctype": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.9",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.7",
+    "@agentproto/tooling": "0.1.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
 }