@tangleai/context 0.21.1

package/src/schemas/ledger.js

@@ -0,0 +1,357 @@
+//@ts-check
+/**
+ * The ledger's four record schemas, as plain JSON Schema documents
+ * compiled by `JarenValidator` when a ledger is constructed. A malformed
+ * write is rejected at the boundary exactly the way a malformed tool call
+ * is — the suite validating its own durable state with its own validator.
+ *
+ * They live in one module rather than four files because they are small,
+ * they share a vocabulary (`at` is an RFC 3339 timestamp everywhere, ids
+ * are non-empty strings everywhere), and one file is where a reader looks
+ * for "what may a ledger hold".
+ *
+ * Why four kinds and not one bag: they differ in every dimension that
+ * matters. Lifetime — a goal is superseded, a memory accumulates, a slot
+ * is garbage. Retrieval — a goal is always in context, memories are
+ * recalled by relevance, slots are addressed by name. Write rule — a
+ * memory or skill may be proposed by a model (and must therefore carry
+ * evidence), a slot is written by the harness and never proposed.
+ */
+
+import { CLAIM_EVIDENCE_SCHEMA } from './evidence.js';
+
+/**
+ * A timestamp property: RFC 3339, the suite's only date representation.
+ *
+ * Both keywords earn their place. `format` is the right metadata and a
+ * host that injects a validator with `@jarenjs/formats` registered gets
+ * real format checking from it — but `format` is annotation-only by
+ * default, so on its own it would enforce NOTHING here, and this package
+ * may not depend on `@jarenjs/formats` to find that out. The `pattern`
+ * is the zero-dependency enforcement, and it is not pedantry: recency
+ * ordering compares these strings lexicographically, so a junk `at`
+ * would not be rejected, it would quietly sort wrong.
+ *
+ * The lexicographic comparison is exact only for a consistent offset.
+ * The ledger's own clock emits `Z`; a host mixing offsets gets ordering
+ * that is off by the difference, which is why the pattern documents the
+ * offset rather than banning it.
+ */
+const AT = {
+  type: 'string',
+  format: 'date-time',
+  pattern: '^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$',
+};
+
+/** A non-empty identifier. */
+const ID = { type: 'string', minLength: 1 };
+
+/**
+ * A stored embedding: a plain array of numbers, never a typed array. A
+ * `Float32Array` does not survive the storage boundary — JSON serializes
+ * it as a dense object — so the ledger's form is what JSON keeps. What
+ * the schema cannot say (every component finite, the length equal to the
+ * identity's `dims`) the ledger checks with `isVector` from
+ * `@jarenjs/core/vector` in the same gate.
+ */
+const EMBEDDING = { type: 'array', items: { type: 'number' }, minItems: 1 };
+
+/**
+ * A vector's identity: which model produced it, at what width. Vectors
+ * from two models are pairwise meaningless and compare into plausible
+ * garbage, so an embedding never travels without this and ranked recall
+ * refuses to mix two.
+ */
+const EMBEDDED_BY = {
+  type: 'object',
+  properties: {
+    model: { type: 'string', minLength: 1 },
+    dims: { type: 'integer', minimum: 1 },
+  },
+  required: ['model', 'dims'],
+  additionalProperties: false,
+};
+
+/**
+ * `embedding` and `embeddedBy` are both-or-neither, and nothing requires
+ * them: an un-embedded record is exactly as valid as it ever was. The
+ * schemas declare no `$schema`, so they compile under the validator's
+ * draft-07 default, where "if this member is present, that one is
+ * required" is spelled `dependencies` (the `dependentRequired` of
+ * 2019-09 and later says the same thing).
+ */
+const EMBEDDING_PAIR = { embedding: ['embeddedBy'], embeddedBy: ['embedding'] };
+
+/**
+ * One active objective. Singular by construction: a second `setGoal`
+ * supersedes this one and archives it, so "what am I doing" has exactly
+ * one answer at any moment.
+ *
+ * `progress` is storage only in this order — an append-only record of
+ * what happened, with the evidence for it. Nothing here interprets a
+ * progress entry or decides when a goal is done.
+ */
+export const GOAL_SCHEMA = {
+  $id: 'https://jarenjs.github.io/schemas/ai/ledger-goal.json',
+  type: 'object',
+  properties: {
+    objective: { type: 'string', minLength: 1 },
+    createdAt: AT,
+    status: { enum: ['active', 'done', 'abandoned', 'superseded'] },
+    progress: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          at: AT,
+          id: ID,
+          note: { type: 'string', minLength: 1 },
+          // an unevidenced progress note is a claim, not a record
+          evidence: { type: 'string', minLength: 1 },
+        },
+        required: ['at', 'note', 'evidence'],
+        additionalProperties: false,
+      },
+    },
+    checkpoint: {
+      type: 'object',
+      properties: {
+        version: { const: 1 },
+        records: { type: 'array', items: { type: 'object', properties: {
+          note: ID, evidence: ID,
+        }, required: ['note', 'evidence'], additionalProperties: false } },
+        sources: { type: 'array', items: { type: 'object', properties: {
+          id: ID, at: AT, record: { type: 'integer', minimum: 0 },
+        }, required: ['id', 'at', 'record'], additionalProperties: false } },
+      },
+      required: ['version', 'records', 'sources'], additionalProperties: false,
+    },
+    retention: { type: 'object', properties: {
+      version: { const: 1 }, reason: { const: 'goal-budget' },
+      retired: { type: 'array', items: ID, uniqueItems: true },
+    }, required: ['version', 'reason', 'retired'], additionalProperties: false },
+  },
+  required: ['objective', 'createdAt', 'status', 'progress'],
+  additionalProperties: false,
+};
+
+/**
+ * A fact worth carrying past this context window.
+ *
+ * `evidence` is REQUIRED, and that is the load-bearing part: a memory
+ * without evidence is not a memory, it is a guess, and a ledger full of
+ * guesses is worse than an empty one. It is also what makes a
+ * model-proposed refinement auditable — the reviewer of a patch can ask
+ * "on what basis" and get an answer from the record itself.
+ *
+ * `embedding` + `embeddedBy` are optional and travel together: a memory
+ * that carries them can be recalled by meaning through the embedder
+ * seam; one that does not is recalled by tag and recency exactly as
+ * before, and ranked recall reports it as skipped rather than scoring it.
+ */
+export const MEMORY_SCHEMA = {
+  $id: 'https://jarenjs.github.io/schemas/ai/ledger-memory.json',
+  type: 'object',
+  properties: {
+    id: ID,
+    text: { type: 'string', minLength: 1 },
+    evidence: { anyOf: [{ type: 'string', minLength: 1 }, CLAIM_EVIDENCE_SCHEMA] },
+    tags: { type: 'array', items: { type: 'string', minLength: 1 } },
+    at: AT,
+    // OPTIONAL, as a pair: the vector `recall({ near })` ranks by, and
+    // the identity that makes it comparable
+    embedding: EMBEDDING,
+    embeddedBy: EMBEDDED_BY,
+  },
+  required: ['id', 'text', 'evidence', 'tags', 'at'],
+  dependencies: EMBEDDING_PAIR,
+  additionalProperties: false,
+};
+
+/**
+ * A reusable recipe: when it applies, what to do, and which tools it
+ * needs. Retrieved like a memory and composed into a system prompt by
+ * whatever drives the agent — the ledger stores it and nothing more.
+ */
+export const PROGRAM_SKILL_SCHEMA = {
+  type: 'object',
+  properties: {
+    version: { const: 1 },
+    question: { type: 'string', minLength: 1 },
+    fingerprint: { type: 'string', pattern: '^[a-f0-9]{64}$' },
+    environmentId: { type: 'string', minLength: 1 },
+    schemaVersion: { type: 'string', minLength: 1 },
+    document: { type: 'object' },
+    evidence: { type: 'string', minLength: 1 },
+    checked: { const: true },
+  },
+  required: ['version', 'question', 'fingerprint', 'environmentId', 'schemaVersion', 'document', 'evidence', 'checked'],
+  additionalProperties: false,
+};
+
+export const SKILL_SCHEMA = {
+  $id: 'https://jarenjs.github.io/schemas/ai/ledger-skill.json',
+  type: 'object',
+  properties: {
+    id: ID,
+    name: { type: 'string', minLength: 1 },
+    when: { type: 'string', minLength: 1 },
+    instructions: { type: 'string', minLength: 1 },
+    program: PROGRAM_SKILL_SCHEMA,
+    tools: { type: 'array', items: { type: 'string', minLength: 1 } },
+    at: AT,
+    // the same optional pair as a memory; the text a skill is embedded
+    // from is its name, when and instructions together
+    embedding: EMBEDDING,
+    embeddedBy: EMBEDDED_BY,
+  },
+  required: ['id', 'name', 'when', 'instructions', 'tools', 'at'],
+  dependencies: EMBEDDING_PAIR,
+  additionalProperties: false,
+};
+
+/**
+ * An addressable blob's METADATA. The content lives under a separate
+ * storage key and never travels with the metadata — that separation is
+ * the whole point: a root request may carry `{ name, kind, size, excerpt }`
+ * for a hundred slots without carrying one slot's content.
+ */
+export const SLOT_SCHEMA = {
+  $id: 'https://jarenjs.github.io/schemas/ai/ledger-slot.json',
+  type: 'object',
+  properties: {
+    name: ID,
+    kind: { type: 'string', minLength: 1 },
+    size: { type: 'integer', minimum: 0 },
+    excerpt: { type: 'string' },
+    at: AT,
+    // OPTIONAL, and optional on purpose: `size` is what a slot costs and
+    // is always known, while `count` is what it CONTAINS — lines,
+    // records, pieces — which only the writer knows and only sometimes.
+    // A root view listing a hundred slots is far more useful with "1 240
+    // lines" beside a size, and a slot whose writer could not say is
+    // better off saying nothing than guessing.
+    count: { type: 'integer', minimum: 0 },
+    pinned: { type: 'boolean' },
+  },
+  required: ['name', 'kind', 'size', 'excerpt', 'at'],
+  additionalProperties: false,
+};
+
+/** Every ledger schema by kind — what `createLedger` compiles at construction. */
+export const LEDGER_SCHEMAS = {
+  goal: GOAL_SCHEMA,
+  memory: MEMORY_SCHEMA,
+  skill: SKILL_SCHEMA,
+  slot: SLOT_SCHEMA,
+};
+
+/*
+ * The record shapes, as named types beside the schemas that enforce them.
+ *
+ * These exist because a strictly-typed consumer (the first one was the
+ * tangleai rebuild, 2026-08-24) otherwise hand-writes its own copy of
+ * "what addMemory returns" and the copy drifts. The schema stays the
+ * runtime contract; the typedef is the same statement made to the
+ * compiler, and the two live in one file so a change to one is a diff
+ * touching the other's neighbourhood.
+ */
+
+/**
+ * One evidenced progress entry on the active goal.
+ * @typedef {object} LedgerProgressEntry
+ * @property {string} [id]
+ * @property {string} at RFC 3339
+ * @property {string} note
+ * @property {string} evidence
+ */
+
+/**
+ * The active (or archived) objective — see {@link GOAL_SCHEMA}.
+ * @typedef {object} LedgerGoal
+ * @property {string} objective
+ * @property {string} createdAt RFC 3339
+ * @property {'active'|'done'|'abandoned'|'superseded'} status
+ * @property {LedgerProgressEntry[]} progress
+ * @property {{ version: 1, records: { note: string, evidence: string }[], sources: { id: string, at: string, record: number }[] }} [checkpoint]
+ * @property {{ version: 1, reason: 'goal-budget', retired: string[] }} [retention]
+ */
+
+/**
+ * A vector's identity — see {@link EMBEDDED_BY}. What `recall({ near })`
+ * compares against the query embedder's `{ model, dims }` before any
+ * arithmetic happens.
+ * @typedef {object} LedgerEmbeddedBy
+ * @property {string} model
+ * @property {number} dims
+ */
+
+/**
+ * The vector pair, both-or-neither — the schemas' `dependencies` rule
+ * (see {@link EMBEDDING_PAIR}) stated in the type: a record either
+ * carries `embedding` AND `embeddedBy`, or neither. `embedding` is the
+ * vector `recall({ near })` ranks by — plain numbers, never a typed
+ * array — and `embeddedBy` its identity. Narrow on either member and
+ * the other follows: `if (record.embedding) record.embeddedBy.dims`.
+ * An orphan vector does not type, just as the ledger refuses it.
+ * @typedef {{ embedding?: undefined, embeddedBy?: undefined }
+ *   | { embedding: number[], embeddedBy: LedgerEmbeddedBy }} LedgerEmbeddingPair
+ */
+
+/**
+ * A stored memory's own members — see {@link MEMORY_SCHEMA}; the
+ * record is these plus {@link LedgerEmbeddingPair}.
+ * @typedef {object} LedgerMemoryFields
+ * @property {string} id
+ * @property {string} text
+ * @property {string | import('./evidence.js').ClaimEvidenceEnvelope} evidence
+ * @property {string[]} tags
+ * @property {string} at RFC 3339
+ */
+
+/**
+ * A stored memory — see {@link MEMORY_SCHEMA}.
+ * @typedef {LedgerMemoryFields & LedgerEmbeddingPair} LedgerMemory
+ */
+
+/**
+ * A stored skill's own members — see {@link SKILL_SCHEMA}; the record
+ * is these plus {@link LedgerEmbeddingPair}.
+ * @typedef {object} LedgerSkillFields
+ * @property {string} id
+ * @property {string} name
+ * @property {string} when
+ * @property {string} instructions
+ * @property {string[]} tools
+ * @property {string} at RFC 3339
+ * @property {{ version: 1, question: string, fingerprint: string, environmentId: string,
+ *   schemaVersion: string, document: any, evidence: string, checked: true }} [program]
+ */
+
+/**
+ * A stored skill — see {@link SKILL_SCHEMA}.
+ * @typedef {LedgerSkillFields & LedgerEmbeddingPair} LedgerSkill
+ */
+
+/**
+ * A slot's metadata — see {@link SLOT_SCHEMA}. Never the content.
+ * @typedef {object} LedgerSlot
+ * @property {string} name
+ * @property {string} kind
+ * @property {number} size
+ * @property {string} excerpt
+ * @property {string} at RFC 3339
+ * @property {number} [count]
+ * @property {boolean} [pinned]
+ */
+
+/**
+ * The one rejection shape every schema-guarded write answers with —
+ * produced by `invalidInput` in `check.js`, named here because this is
+ * where a consumer of the ledger's API goes looking for "what comes
+ * back when a write is refused".
+ * @typedef {object} LedgerRejection
+ * @property {string} error
+ * @property {any[]} errors
+ * @property {any} inputSchema
+ */

package/src/schemas/patch.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Path-discriminated RFC 6902 operations. Provider decoding uses this same
+ * schema in non-strict mode; local validation remains authoritative.
+ * @param {{ maxOps?: number }} [options]
+ * @returns {any}
+ */
+export function refinementPatchSchema(options?: {
+    maxOps?: number;
+}): any;
+/**
+ * Where a refinement may write. Anchored, and read as: append or address
+ * one memory, append or address one skill, append one progress entry.
+ *
+ * `-` is RFC 6902's "end of array" and is how an append is written.
+ * There is deliberately no way to address INSIDE a record (`/memories/0/text`):
+ * a memory is revised by replacing it whole, with fresh evidence, so
+ * that every stored record was validated as a whole exactly once.
+ */
+export const REFINEMENT_PATH_PATTERN: "^(/memories/(-|[0-9]+)|/skills/(-|[0-9]+)|/goal/progress/-)$";
+/** The default cap on operations per refinement. */
+export const DEFAULT_MAX_OPS: 6;
+export namespace MEMORY_PROPOSAL_SCHEMA {
+    let type: string;
+    namespace properties {
+        namespace text {
+            let type_1: string;
+            export { type_1 as type };
+            export let minLength: number;
+            export let description: string;
+        }
+        namespace evidence {
+            let anyOf: ({
+                type: "object";
+                properties: Record<string, object>;
+                required: string[];
+                additionalProperties: false;
+            } | {
+                type: string;
+                minLength: number;
+            })[];
+        }
+        namespace tags {
+            let type_2: string;
+            export { type_2 as type };
+            export namespace items {
+                let type_3: string;
+                export { type_3 as type };
+                let minLength_1: number;
+                export { minLength_1 as minLength };
+            }
+        }
+    }
+    let required: string[];
+    let additionalProperties: boolean;
+}
+export namespace SKILL_PROPOSAL_SCHEMA {
+    let type_4: string;
+    export { type_4 as type };
+    export namespace properties_1 {
+        namespace name {
+            let type_5: string;
+            export { type_5 as type };
+            let minLength_2: number;
+            export { minLength_2 as minLength };
+        }
+        namespace when {
+            let type_6: string;
+            export { type_6 as type };
+            let minLength_3: number;
+            export { minLength_3 as minLength };
+            let description_1: string;
+            export { description_1 as description };
+        }
+        namespace instructions {
+            let type_7: string;
+            export { type_7 as type };
+            let minLength_4: number;
+            export { minLength_4 as minLength };
+            let description_2: string;
+            export { description_2 as description };
+        }
+        namespace tools {
+            let type_8: string;
+            export { type_8 as type };
+            export namespace items_1 {
+                let type_9: string;
+                export { type_9 as type };
+                let minLength_5: number;
+                export { minLength_5 as minLength };
+            }
+            export { items_1 as items };
+        }
+    }
+    export { properties_1 as properties };
+    let required_1: string[];
+    export { required_1 as required };
+    let additionalProperties_1: boolean;
+    export { additionalProperties_1 as additionalProperties };
+}
+export namespace PROGRESS_PROPOSAL_SCHEMA {
+    let type_10: string;
+    export { type_10 as type };
+    export namespace properties_2 {
+        export namespace note {
+            let type_11: string;
+            export { type_11 as type };
+            let minLength_6: number;
+            export { minLength_6 as minLength };
+            let description_3: string;
+            export { description_3 as description };
+        }
+        export namespace evidence_1 {
+            let type_12: string;
+            export { type_12 as type };
+            let minLength_7: number;
+            export { minLength_7 as minLength };
+            let description_4: string;
+            export { description_4 as description };
+        }
+        export { evidence_1 as evidence };
+    }
+    export { properties_2 as properties };
+    let required_2: string[];
+    export { required_2 as required };
+    let additionalProperties_2: boolean;
+    export { additionalProperties_2 as additionalProperties };
+}
+/** The full schema used for handwritten and generated proposals alike. */
+export const REFINEMENT_PATCH_SCHEMA: any;

package/src/schemas/patch.js

@@ -0,0 +1,135 @@
+//@ts-check
+/**
+ * The refinement patch: a deliberately small subset of RFC 6902.
+ *
+ * A model that has finished a run is asked what it learned. The unsafe
+ * answer is a rewritten prompt or a restated set of memories — a
+ * rewrite is unreviewable, unbounded, and a model asked to restate what
+ * it remembers will drift it. The safe answer is a PATCH: small enough
+ * to read, addressed enough to audit, and reversible with a snapshot.
+ *
+ * Three restrictions, and each one exists because the alternative fails
+ * on the tier this package targets:
+ *
+ *  - **`path` is a pattern, not a free string.** It matches exactly the
+ *    supplemental subtree — append or replace a memory, append or
+ *    replace a skill, append one progress entry — and nothing else. The
+ *    base system prompt is not merely undocumented as a target, it is
+ *    unaddressable: it is not in the document a refinement is applied
+ *    to, and no path that could reach it matches this pattern. That is
+ *    D5 asserted rather than described.
+ *  - **`op` is three verbs.** `move`, `copy` and `test` are legal RFC
+ *    6902 and useless here; every one of them is another shape a small
+ *    model can get subtly wrong, and none of them expresses anything
+ *    `add`/`replace`/`remove` cannot.
+ *  - **The number of operations is capped.** A refinement is meant to be
+ *    a few evidence-backed updates. A patch of forty operations is a
+ *    rewrite wearing a patch's clothes, and it is also the shape that
+ *    makes a repair round useless — the model cannot tell which of forty
+ *    operations the error came from.
+ *
+ * `value` carries no `id` and no `at` on purpose. Identity and time are
+ * the ledger's to mint: a model that could choose an id could overwrite
+ * a record it never read, and a model that could choose a timestamp
+ * could put a memory in front of one that came later — the recency
+ * ordering everything downstream depends on is not the model's to set.
+ */
+
+import { CLAIM_EVIDENCE_SCHEMA } from './evidence.js';
+
+/**
+ * Where a refinement may write. Anchored, and read as: append or address
+ * one memory, append or address one skill, append one progress entry.
+ *
+ * `-` is RFC 6902's "end of array" and is how an append is written.
+ * There is deliberately no way to address INSIDE a record (`/memories/0/text`):
+ * a memory is revised by replacing it whole, with fresh evidence, so
+ * that every stored record was validated as a whole exactly once.
+ */
+export const REFINEMENT_PATH_PATTERN =
+  '^(/memories/(-|[0-9]+)|/skills/(-|[0-9]+)|/goal/progress/-)$';
+
+/** The default cap on operations per refinement. */
+export const DEFAULT_MAX_OPS = 6;
+
+/**
+ * A proposed memory. `evidence` is required here AND by the ledger's own
+ * schema — the same requirement twice, on purpose: this copy is what
+ * constrains decoding (a model generating against it tends to write the
+ * evidence rather than be corrected into it), and the ledger's copy is
+ * what makes the rule true even for a patch that never went near a
+ * model. It is the mechanism that stops a refinement laundering a
+ * hallucination into durable state.
+ */
+export const MEMORY_PROPOSAL_SCHEMA = {
+  type: 'object',
+  properties: {
+    text: { type: 'string', minLength: 1, description: 'The fact worth carrying, in one sentence.' },
+    evidence: { anyOf: [{ type: 'string', minLength: 1 }, CLAIM_EVIDENCE_SCHEMA] },
+    tags: { type: 'array', items: { type: 'string', minLength: 1 } },
+  },
+  required: ['text', 'evidence'],
+  additionalProperties: false,
+};
+
+/** A proposed skill: when it applies, what to do, which tools it needs. */
+export const SKILL_PROPOSAL_SCHEMA = {
+  type: 'object',
+  properties: {
+    name: { type: 'string', minLength: 1 },
+    when: { type: 'string', minLength: 1, description: 'The situation this recipe applies to.' },
+    instructions: { type: 'string', minLength: 1, description: 'The steps, concretely.' },
+    tools: { type: 'array', items: { type: 'string', minLength: 1 } },
+  },
+  required: ['name', 'when', 'instructions'],
+  additionalProperties: false,
+};
+
+/** A proposed progress entry against the active goal. */
+export const PROGRESS_PROPOSAL_SCHEMA = {
+  type: 'object',
+  properties: {
+    note: { type: 'string', minLength: 1, description: 'What was done or established.' },
+    evidence: { type: 'string', minLength: 1, description: 'What in the run establishes it.' },
+  },
+  required: ['note', 'evidence'],
+  additionalProperties: false,
+};
+
+/**
+ * Path-discriminated RFC 6902 operations. Provider decoding uses this same
+ * schema in non-strict mode; local validation remains authoritative.
+ * @param {{ maxOps?: number }} [options]
+ * @returns {any}
+ */
+export function refinementPatchSchema(options = {}) {
+  const maxOps = options.maxOps ?? DEFAULT_MAX_OPS;
+  if (!Number.isSafeInteger(maxOps) || maxOps < 0)
+    throw new TypeError('maxOps must be a non-negative safe integer');
+  const branch = (op, pattern, value) => ({
+    type: 'object',
+    properties: { op: { enum: op }, path: { type: 'string', pattern },
+      ...(value ? { value } : {}) },
+    required: value ? ['op', 'path', 'value'] : ['op', 'path'],
+    additionalProperties: false,
+  });
+  const index = '(0|[1-9][0-9]*)';
+  return {
+    $id: 'https://jarenjs.github.io/schemas/ai/refinement-patch.json',
+    title: 'Refinement patch',
+    type: 'array', maxItems: maxOps,
+    $defs: { memory: MEMORY_PROPOSAL_SCHEMA, skill: SKILL_PROPOSAL_SCHEMA,
+      progress: PROGRESS_PROPOSAL_SCHEMA },
+    items: { oneOf: [
+      ...[['memories', 'memory'], ['skills', 'skill']].flatMap(([path, kind]) => [
+        branch(['add'], `^/${path}/(-|${index})$`, { $ref: `#/$defs/${kind}` }),
+        branch(['replace'], `^/${path}/${index}$`, { $ref: `#/$defs/${kind}` }),
+        branch(['remove'], `^/${path}/${index}$`, null),
+      ]),
+      branch(['add'], '^/goal/progress/-$', { $ref: '#/$defs/progress' }),
+    ] },
+  };
+}
+
+/** The full schema used for handwritten and generated proposals alike. */
+export const REFINEMENT_PATCH_SCHEMA = refinementPatchSchema();