@kontourai/flow-agents 0.3.0 → 0.4.0

package/kits/knowledge/adapters/similarity-vector/index.js

@@ -0,0 +1,284 @@
+/**
+ * Knowledge Kit — Vector Similarity Adapter
+ *
+ * Provides a drop-in SimilarityDetector implementation backed by dense vector
+ * embeddings (cosine similarity) instead of the default category-prefix /
+ * link-overlap heuristic.
+ *
+ * SimilarityDetector interface (from adapters/flow-runner/index.js):
+ *   async (concept: Record, candidates: Record[], store: KnowledgeStoreAdapter) => string[]
+ *
+ * Usage:
+ *   import { createVectorSimilarityDetector } from './adapters/similarity-vector/index.js';
+ *
+ *   // Ollama (default):
+ *   const detector = createVectorSimilarityDetector();
+ *
+ *   // Ollama with non-default model/host:
+ *   const detector = createVectorSimilarityDetector({
+ *     host: 'http://localhost:11434',
+ *     model: 'nomic-embed-text',
+ *     threshold: 0.60,
+ *   });
+ *
+ *   // Injectable embed fn (for tests / custom providers):
+ *   const detector = createVectorSimilarityDetector({
+ *     embed: async (texts) => texts.map(() => [0.1, 0.9, 0.0]),
+ *     threshold: 0.60,
+ *   });
+ *
+ *   // Pass to synthesize:
+ *   await runner.synthesize(conceptId, {
+ *     proposedBody: '...',
+ *     rationale: '...',
+ *     similarityDetector: detector,
+ *   });
+ *
+ * Zero npm dependencies — uses Node.js built-in fetch (Node >= 18).
+ *
+ * Fail-closed policy:
+ *   If the embedding call fails (network error, non-200, malformed response),
+ *   the detector throws an Error with code="EMBED_FAILURE". This is intentional:
+ *   silently returning [] would look identical to "no similar records found" and
+ *   mask infrastructure failures as legitimate empty clusters, blocking synthesis
+ *   with a misleading MISSING_EVIDENCE rather than a clear infrastructure error.
+ *
+ * @module adapters/similarity-vector
+ */
+
+// ---------------------------------------------------------------------------
+// Pure cosine similarity (exported for tests)
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the cosine similarity between two equal-length numeric vectors.
+ *
+ * Returns a value in [-1, 1]:
+ *   1.0  — identical direction
+ *   0.0  — orthogonal
+ *  -1.0  — opposite direction
+ *
+ * Edge cases:
+ *   - Zero-magnitude vector(s): returns 0 (no similarity signal).
+ *   - Empty or unequal-length vectors: returns 0.
+ *
+ * @param {number[]} a
+ * @param {number[]} b
+ * @returns {number}
+ */
+export function cosineSimilarity(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return 0;
+  if (a.length !== b.length || a.length === 0) return 0;
+
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  if (denom === 0) return 0;
+  return dot / denom;
+}
+
+// ---------------------------------------------------------------------------
+// Ollama embed call
+// ---------------------------------------------------------------------------
+
+/**
+ * Call ollama's /api/embed endpoint.
+ *
+ * Throws an Error with code="EMBED_FAILURE" on any failure.
+ *
+ * @param {string} host
+ * @param {string} model
+ * @param {string[]} texts
+ * @returns {Promise<number[][]>}
+ */
+async function ollamaEmbed(host, model, texts) {
+  const url = `${host}/api/embed`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, input: texts }),
+    });
+  } catch (cause) {
+    const err = new Error(
+      `EMBED_FAILURE: embedding call to ${url} failed — ${cause.message}`
+    );
+    err.code = "EMBED_FAILURE";
+    err.cause = cause;
+    throw err;
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "(unreadable)");
+    const err = new Error(
+      `EMBED_FAILURE: embedding call to ${url} returned HTTP ${response.status}: ${body}`
+    );
+    err.code = "EMBED_FAILURE";
+    throw err;
+  }
+
+  let data;
+  try {
+    data = await response.json();
+  } catch (cause) {
+    const err = new Error(
+      `EMBED_FAILURE: embedding response from ${url} was not valid JSON — ${cause.message}`
+    );
+    err.code = "EMBED_FAILURE";
+    err.cause = cause;
+    throw err;
+  }
+
+  // ollama /api/embed returns { embeddings: number[][] }
+  if (!data.embeddings || !Array.isArray(data.embeddings)) {
+    const err = new Error(
+      `EMBED_FAILURE: embedding response missing .embeddings array (got: ${JSON.stringify(Object.keys(data || {}))})`
+    );
+    err.code = "EMBED_FAILURE";
+    throw err;
+  }
+
+  if (data.embeddings.length !== texts.length) {
+    const err = new Error(
+      `EMBED_FAILURE: expected ${texts.length} embedding(s), got ${data.embeddings.length}`
+    );
+    err.code = "EMBED_FAILURE";
+    throw err;
+  }
+
+  return data.embeddings;
+}
+
+// ---------------------------------------------------------------------------
+// createVectorSimilarityDetector
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a SimilarityDetector backed by dense vector embeddings.
+ *
+ * The returned detector satisfies the SimilarityDetector interface:
+ *   async (concept, candidates, store) => string[]
+ *
+ * @param {object} [options]
+ * @param {((texts: string[]) => Promise<number[][]>)} [options.embed]
+ *   Injectable embedding function. When provided, `host` and `model` are
+ *   ignored. Signature: async (texts: string[]) => number[][]
+ *   Must return one vector per input text.
+ * @param {string} [options.host="http://localhost:11434"]
+ *   Ollama server base URL. Used when `embed` is not provided.
+ * @param {string} [options.model="nomic-embed-text"]
+ *   Embedding model name passed to ollama. Used when `embed` is not provided.
+ * @param {number} [options.threshold=0.60]
+ *   Minimum cosine similarity score for a candidate to be included.
+ *   Range: [-1, 1]. Default 0.60 is calibrated for nomic-embed-text where
+ *   semantically related texts from the same domain typically score ≥ 0.70
+ *   and unrelated texts score < 0.50.
+ * @param {((record: object) => string)} [options.text]
+ *   Extractor that converts a store record to the text to embed.
+ *   Default: `record.title + "\n" + record.body`.
+ * @returns {(concept: object, candidates: object[], store: object) => Promise<string[]>}
+ */
+export function createVectorSimilarityDetector(options = {}) {
+  const {
+    embed: injectEmbed = null,
+    host = "http://localhost:11434",
+    model = "nomic-embed-text",
+    threshold = 0.60,
+    text: extractText = defaultTextExtractor,
+  } = options;
+
+  // Resolve the actual embed function once (avoid re-resolving on each call)
+  const embedFn = injectEmbed
+    ? injectEmbed
+    : (texts) => ollamaEmbed(host, model, texts);
+
+  /**
+   * SimilarityDetector: returns candidate IDs whose cosine similarity to the
+   * concept embedding meets or exceeds `threshold`.
+   *
+   * Fail-closed: any embedding failure throws EMBED_FAILURE rather than
+   * silently returning [].
+   *
+   * @param {object} concept
+   * @param {object[]} candidates
+   * @param {object} _store  (not used by vector detector; kept for interface compat)
+   * @returns {Promise<string[]>}
+   */
+  async function vectorSimilarityDetector(concept, candidates, _store) {
+    if (!candidates || candidates.length === 0) {
+      return [];
+    }
+
+    // Exclude retired records from the working set (Addendum B — R3)
+    const activeCandidates = candidates.filter(
+      (c) => (c.status || "active") !== "retired"
+    );
+
+    if (activeCandidates.length === 0) {
+      return [];
+    }
+
+    const conceptText = extractText(concept);
+
+    // Build the batch: concept first, then all active candidates.
+    // One round-trip minimises latency and keeps the batch API simple.
+    const allTexts = [conceptText, ...activeCandidates.map(extractText)];
+
+    // Embedding call — throws EMBED_FAILURE on any infrastructure error.
+    const embeddings = await embedFn(allTexts);
+
+    // Validate count: the embed fn must return one vector per input text.
+    // A count mismatch would produce silent wrong results (undefined vectors
+    // scoring 0 and being excluded) — throw EMBED_FAILURE instead.
+    if (!Array.isArray(embeddings) || embeddings.length !== allTexts.length) {
+      const err = new Error(
+        `EMBED_FAILURE: embed function returned ${Array.isArray(embeddings) ? embeddings.length : typeof embeddings} vector(s) but expected ${allTexts.length} (1 concept + ${activeCandidates.length} active candidates)`
+      );
+      err.code = 'EMBED_FAILURE';
+      throw err;
+    }
+
+    const conceptVec = embeddings[0];
+    const similar = [];
+
+    for (let i = 0; i < activeCandidates.length; i++) {
+      const candidateVec = embeddings[i + 1];
+      const score = cosineSimilarity(conceptVec, candidateVec);
+      if (score >= threshold) {
+        similar.push(activeCandidates[i].id);
+      }
+    }
+
+    return similar;
+  }
+
+  return vectorSimilarityDetector;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Default text extractor: title + newline + body.
+ * Gracefully handles missing fields.
+ *
+ * @param {object} record
+ * @returns {string}
+ */
+function defaultTextExtractor(record) {
+  const title = record?.title || "";
+  const body = record?.body || "";
+  return `${title}\n${body}`;
+}
+
+export default createVectorSimilarityDetector;

package/kits/knowledge/docs/README.md

@@ -24,6 +24,15 @@ See [`store-contract.md`](store-contract.md) for the full specification. Quick r
 | `raw` | Unprocessed source material — excerpts, transcripts, URLs with notes. |
 | `compiled` | Normalized, editor-reviewed distillations of raw records. |
 | `concept` | Named ideas or principles that other records reference. |
+| `snapshot` | Bounded decision summary for a topic (Addendum A). |
+
+**Record status lifecycle**
+
+| Status | Meaning | Default |
+|---|---|---|
+| `active` | Live, part of the working set. | Yes (records without status field are treated as active). |
+| `implemented` | Decision was shipped; transitional state before archival. | No |
+| `retired` | Excluded from default working-set queries; history preserved. | No |
 
 **Mutation operations**
 
@@ -35,6 +44,8 @@ See [`store-contract.md`](store-contract.md) for the full specification. Quick r
 | `propose` | `agent`, `proposal` (non-empty) |
 | `apply` | `agent`, `new_body` (non-empty), `rationale` (non-empty) |
 | `reject` | `agent`, `reason` (non-empty) |
+| `supersede` | `agent`, `rationale` (non-empty), non-empty `supersededIds` array |
+| `retire` | `agent`, `rationale` (non-empty), `implementedByRef` (when `targetStatus="implemented"`) |
 
 Every mutation throws with `error.code === "MISSING_EVIDENCE"` when required evidence is absent.
 
@@ -127,9 +138,191 @@ and adapter infrastructure remain the foundation.
 
 ---
 
+## Decision Lifecycle — Retiring Records (S7)
+
+Implemented or obsolete records can be retired from the working set via the `knowledge.retire`
+flow. Retirement is **non-destructive**: the record body, links, and creation provenance remain
+intact; the record is simply excluded from the default working set.
+
+### Status transitions
+
+| From | To | Evidence required |
+|---|---|---|
+| `active` | `implemented` | `rationale` (non-empty) + `implementedByRef` (non-empty ref to implementing artifact) |
+| `active` | `retired` | `rationale` (non-empty) |
+| `implemented` | `retired` | `rationale` (non-empty) |
+| `retired` | *(any)* | Invalid — `retired` is terminal |
+
+### Working-set exclusion
+
+Retired records are excluded from:
+
+- `listByType(type)` — default query
+- `listByCategory(category, options)` — default query
+- `defaultSimilarityDetector` — default cluster candidates
+- `createVectorSimilarityDetector` — vector cluster candidates
+
+Add `{ includeRetired: true }` to any query to restore retired records.
+
+`get(id)` **always** returns the full record regardless of status.
+
+### Using the retire flow
+
+```js
+import { KnowledgeFlowRunner } from './adapters/flow-runner/index.js';
+
+const runner = new KnowledgeFlowRunner({ store, workspace });
+
+// Retire a compiled decision record that was implemented
+const result = await runner.retire(compiledId, {
+  targetStatus: 'implemented',
+  rationale: 'REST API shipped in v1.0 (PR #42).',
+  implementedByRef: 'https://github.com/org/repo/pull/42',
+  decision: 'apply',
+});
+
+// Retire an obsolete concept record
+await runner.retire(conceptId, {
+  targetStatus: 'retired',
+  rationale: 'Superseded by new architecture decision in ADR-007.',
+  decision: 'apply',
+});
+
+// Reject a retirement proposal (status unchanged)
+await runner.retire(recordId, {
+  targetStatus: 'retired',
+  rationale: 'Proposing retirement.',
+  decision: 'reject',
+  rejectReason: 'Still needed for reference.',
+});
+```
+
+### Accessing retired records with provenance
+
+```js
+// Always works — returns full record including retirement evidence
+const record = await store.get(retiredId);
+console.log(record.status);           // "retired"
+console.log(record.mutation_log);     // includes retire entry with rationale
+
+// Query all retired records of a type
+const allCompiled = await store.listByType('compiled', { includeRetired: true });
+
+// Get history from snapshot provenance
+const snapshot = await store.get(snapshotId);
+for (const srcId of snapshot.provenance.source_ids) {
+  const src = await store.get(srcId);   // works even if src is retired
+  console.log(src.id, src.status);
+}
+```
+
+---
+
 ## Non-Goals (this iteration)
 
 - Vector/semantic retrieval (parked as I10)
 - Multi-user concurrency
 - Store migrations
 - Personal-KB import (parked as I11)
+
+---
+
+## Similarity Detectors
+
+The `synthesize` and `consolidate` flows accept a pluggable `similarityDetector` option. A
+detector has the signature:
+
+```js
+async (concept: Record, candidates: Record[], store: KnowledgeStoreAdapter) => string[]
+```
+
+It receives the target concept, all compiled candidates, and the store; it returns the IDs of
+candidates that are similar enough to form a cluster. The `KnowledgeFlowRunner` uses the cluster
+as its evidence base — an empty cluster throws `MISSING_EVIDENCE` at the detect-cluster gate.
+
+### Choosing a detector
+
+| Detector | Best for | Tradeoff |
+|---|---|---|
+| `defaultSimilarityDetector` (built-in) | Fast, zero-config. Works well when records share a structured category taxonomy and inter-record wikilinks. | Relies on category prefixes and link-overlap (Jaccard ≥ 0.10). Misses semantic similarity across category boundaries. |
+| `createVectorSimilarityDetector` | Semantic clustering. Finds similar records regardless of how they were categorised. | Requires an embedding backend (ollama by default). Adds latency proportional to cluster size. |
+
+### Vector detector — ollama embedding
+
+The vector adapter lives at `adapters/similarity-vector/index.js`. It is zero-dependency and
+calls ollama's `/api/embed` endpoint via the built-in `fetch`.
+
+```js
+import { createVectorSimilarityDetector } from './adapters/similarity-vector/index.js';
+
+// Default: uses ollama at localhost:11434 with nomic-embed-text
+const detector = createVectorSimilarityDetector();
+
+// Or customise host, model, and threshold:
+const detector = createVectorSimilarityDetector({
+  host: 'http://localhost:11434',
+  model: 'nomic-embed-text',
+  threshold: 0.60,              // cosine similarity cutoff
+});
+
+// Pass to synthesize:
+await runner.synthesize(conceptId, {
+  proposedBody: '...',
+  rationale: '...',
+  similarityDetector: detector,
+});
+```
+
+**Starting ollama:**
+
+```bash
+ollama serve &
+ollama pull nomic-embed-text   # 274 MB, one-time pull
+```
+
+**Threshold guidance:**
+
+The default threshold of `0.60` is validated against `nomic-embed-text` (768-dim). Empirical
+scores observed in the eval suite:
+
+| Pair | Score |
+|---|---|
+| Semantically similar API design texts | ~0.77 |
+| Semantically unrelated (API vs. bread baking) | ~0.41 |
+
+A threshold of `0.60` cleanly separates these two classes. If your domain records are more
+homogeneous (narrow vocabulary, very similar boilerplate) you may need to raise the threshold
+to `0.70–0.80` to avoid over-clustering.
+
+### Fail-closed rationale
+
+The vector detector throws an `Error` with `code="EMBED_FAILURE"` rather than returning `[]`
+when the embedding call fails (network error, HTTP error, malformed response, wrong vector
+count). This is intentional.
+
+A detector that silently returns `[]` on infrastructure failure is indistinguishable from one
+that found no similar records. The result is a misleading `MISSING_EVIDENCE` at the detect-cluster
+gate, which looks like "this concept has no sources" rather than "the embedding service is down".
+
+Failing closed makes the infrastructure problem visible immediately, at the right level, with a
+clear error code. Operators can catch `EMBED_FAILURE` separately from `MISSING_EVIDENCE` and
+route them to different alerting channels.
+
+### Injecting a custom embed function
+
+For tests or alternative providers (OpenAI, Cohere, etc.), pass `embed` directly:
+
+```js
+const detector = createVectorSimilarityDetector({
+  embed: async (texts) => {
+    // texts: string[] — one per record (title + "\n" + body by default)
+    // must return: number[][] — one vector per input text
+    const response = await myEmbeddingAPI.embed(texts);
+    return response.vectors;
+  },
+  threshold: 0.70,
+});
+```
+
+The `embed` function is called once per `synthesize`/`consolidate` call with all texts in a
+single batch (concept first, then candidates).

package/kits/knowledge/docs/store-contract.md

@@ -524,3 +524,127 @@ Superseded snapshots MUST remain queryable:
 
 There is no `"archived"` or `"deleted"` status field; the supersession chain is expressed entirely
 through links and mutation log entries.
+
+---
+
+## Addendum B — Record Status Lifecycle (S7)
+
+### B.1 Status Field
+
+Every record envelope (§1.1) gains an optional `status` field:
+
+| Field | Type | Required | Default | Description |
+|---|---|---|---|---|
+| `status` | `"active"` \| `"implemented"` \| `"retired"` | no | `"active"` | Lifecycle status of the record. Records without a status field are treated as `"active"`. |
+
+`status` is a mutable field but MUST only change via the `retire` mutation op (§B.4).
+Direct field updates via the `update` op MUST NOT change `status`; `update` MUST ignore `status` if
+supplied in the fields argument.
+
+### B.2 Allowed Status Transitions
+
+| From | To | Op | Required Evidence |
+|---|---|---|---|
+| `"active"` | `"implemented"` | `retire` | `implementedByRef` (non-empty, references the implementing artifact/commit/PR) |
+| `"active"` | `"retired"` | `retire` | `rationale` (non-empty, explains obsolescence) |
+| `"implemented"` | `"retired"` | `retire` | `rationale` (non-empty) |
+
+No other transitions are permitted. Attempting an invalid transition MUST throw with
+`error.code === "MISSING_EVIDENCE"` and a human-readable `message`.
+
+Records in `"retired"` status have no further transitions — they are terminal.
+
+### B.3 Working-Set Exclusion
+
+Records with `status === "retired"` are EXCLUDED from the default working set:
+
+- `listByType(type)` returns only non-retired records by default.
+- `listByCategory(category, options?)` returns only non-retired records by default.
+- `defaultSimilarityDetector` considers only non-retired compiled records as candidates.
+- The vector similarity detector (`createVectorSimilarityDetector`) considers only non-retired
+  compiled records as candidates.
+
+All four filtering surfaces accept an `includeRetired: true` option (or equivalent flag on the
+similarity detector) to restore retired records to the result set.
+
+Retired records remain **fully queryable with provenance**:
+- `get(id)` always returns the full record regardless of status.
+- `listByType(type, { includeRetired: true })` returns all records of that type.
+- `listByCategory(category, { includeRetired: true })` returns all matching records.
+- The record's `mutation_log` carries the full retirement evidence.
+
+### B.4 `retire` Mutation Operation
+
+The `retire` op transitions a record from `"active"` or `"implemented"` to the target status.
+It NEVER deletes the record. The record body, links, and provenance remain intact.
+
+**Required fields:**
+
+| Field | Location | Description |
+|---|---|---|
+| `id` | argument | ID of the record to retire. |
+| `targetStatus` | argument | Target status: `"implemented"` or `"retired"`. |
+| `agent` | evidence | Agent performing the retirement. |
+| `rationale` | evidence | Non-empty string explaining why the record is being retired. Required for all target statuses. |
+
+**Conditional evidence fields:**
+
+| Field | Location | Condition | Description |
+|---|---|---|---|
+| `implementedByRef` | evidence | `targetStatus === "implemented"` | Non-empty reference to the implementing artifact (commit SHA, PR URL, issue number, etc.). |
+| `supersededByRef` | evidence | optional for `targetStatus === "retired"` | Reference to a superseding record or artifact. |
+
+**Rejection conditions:**
+- Record with `id` does not exist.
+- `targetStatus` is not `"implemented"` or `"retired"`.
+- Current status transition is invalid (see §B.2).
+- `rationale` is missing or empty.
+- `targetStatus === "implemented"` and `implementedByRef` is missing or empty.
+- Missing `agent` in evidence.
+
+**Post-conditions:**
+- Record `status` is updated to `targetStatus`.
+- Record `updated_at` is refreshed.
+- A mutation log entry (op=`"retire"`) is appended, carrying `targetStatus`, `rationale`,
+  and any supplied `implementedByRef` / `supersededByRef`.
+- The record body, `links`, and creation `provenance` are NOT changed.
+- `get(id)` returns the full record with the updated status.
+- `listByType(type)` (without `includeRetired`) no longer returns this record if
+  `targetStatus === "retired"`.
+
+### B.5 Adapter Contract Extension
+
+The adapter interface (§8) is extended:
+
+```ts
+interface KnowledgeStoreAdapter {
+  // ... existing methods ...
+  retire(id: string, targetStatus: "implemented" | "retired", evidence: RetireEvidence): Promise<void>;
+  listByType(type: RecordType, options?: { includeRetired?: boolean }): Promise<Record[]>;
+  listByCategory(category: string, options?: { prefix?: boolean; includeRetired?: boolean }): Promise<Record[]>;
+}
+```
+
+`RetireEvidence`:
+```ts
+interface RetireEvidence {
+  agent: string;
+  rationale: string;
+  implementedByRef?: string;   // required when targetStatus === "implemented"
+  supersededByRef?: string;    // optional
+  note?: string;
+}
+```
+
+### B.6 Provenance and History Guarantee
+
+Retired records MUST remain reachable from:
+- `get(id)` — always returns the full record.
+- `listByType(type, { includeRetired: true })` and `listByCategory(category, { includeRetired: true })`.
+- Snapshot `provenance.source_ids` — any snapshot that included the record in its cluster before
+  retirement retains the reference intact. The retired record can be retrieved via `get(sourceId)`.
+- The retirement `mutation_log` entry carries the full evidence of why and when the record was
+  retired and by whom.
+
+There is no deletion of records. Physical purge (if ever needed) is a separate, future policy
+hook not defined in this version.

package/kits/knowledge/evals/contract-suite/suite.test.js

@@ -411,12 +411,17 @@ describe("Knowledge Kit Store Contract Suite", () => {
       );
     });
 
-    test("rejects non-concept concept_id", async () => {
-      const notConcept = await store.create({ type: "raw", title: "NC", body: "nc", category: "test", provenance: { agent: "tester" } });
+    test("propose accepts any record type as target (Addendum B: retire flow needs non-concept targets)", async () => {
+      // Addendum B (S7) extends propose to accept any record type as the target,
+      // enabling the retire flow to attach proposals to compiled/raw/snapshot records.
+      const rawTarget = await store.create({ type: "raw", title: "NC", body: "nc", category: "test", provenance: { agent: "tester" } });
       const pid = await store.create({ type: "raw", title: "P3", body: "p", category: "test", provenance: { agent: "tester" } });
-      await assertMissingEvidence(
-        () => store.propose(notConcept, pid, { agent: "tester", proposal: "change" }),
-        "propose non-concept target"
+      // Should NOT throw — all record types are valid proposal targets
+      await store.propose(rawTarget, pid, { agent: "tester", proposal: "retirement proposal" });
+      const { forward } = await store.getLinks(pid);
+      assert.ok(
+        forward.some((l) => l.target_id === rawTarget && l.kind === "proposes"),
+        "propose on raw record creates proposes link (Addendum B extension)"
       );
     });