refactor(cognitive-pipeline): finish rename + clean lingering JSDoc refs

Replaces leftover `guardrails` variable name with `pipeline` in
CognitivePipeline README and tests. Rewrites the remaining
"multi-stage guardrails" references in ingest-router JSDoc plus the
memory-router README link text to point at "Cognitive Pipeline"
instead. No behavior change.

Author: jddunn

src/cognitive-pipeline/README.md

@@ -65,7 +65,7 @@ const ingestRouter = new IngestRouter({ /* ... */ });
 const memoryRouter = new MemoryRouter({ /* ... */ });
 const readRouter = new ReadRouter({ /* ... */ });
 
-const guardrails = new CognitivePipeline({
+const pipeline = new CognitivePipeline({
   ingest: ingestRouterAsStage(ingestRouter),
   recall: memoryRouterAsStage(memoryRouter),
   read: readRouterAsStage(readRouter),
@@ -76,12 +76,12 @@ const guardrails = new CognitivePipeline({
 
 ```ts
 // Independent stages:
-await guardrails.ingest(newContent);                 // input stage
-const recalled = await guardrails.recall(query);     // recall stage
-const answer = await guardrails.read(query, recalled.traces);  // read stage
+await pipeline.ingest(newContent);                 // input stage
+const recalled = await pipeline.recall(query);     // recall stage
+const answer = await pipeline.read(query, recalled.traces);  // read stage
 
 // End-to-end recall + read:
-const result = await guardrails.recallAndRead(query);
+const result = await pipeline.recallAndRead(query);
 console.log(result.outcome);                          // final answer
 console.log(result.recallStage.backend);              // which memory backend ran
 console.log(result.readStage.strategy);               // which reader strategy ran
@@ -92,13 +92,13 @@ console.log(result.recallStage.memoryRouterDecision); // full decision telemetry
 
 ```ts
 // Recall + read only (ingest is handled elsewhere):
-const guardrails = new CognitivePipeline({
+const pipeline = new CognitivePipeline({
   recall: memoryRouterAsStage(memoryRouter),
   read: readRouterAsStage(readRouter),
 });
 
-await guardrails.recallAndRead(query);   // works
-await guardrails.ingest(content);        // throws MissingStageError
+await pipeline.recallAndRead(query);   // works
+await pipeline.ingest(content);        // throws MissingStageError
 ```
 
 ### Custom stage implementations
@@ -117,7 +117,7 @@ const customIngest: IngestStage = {
   },
 };
 
-const guardrails = new CognitivePipeline({
+const pipeline = new CognitivePipeline({
   ingest: customIngest,
   // ...
 });

src/cognitive-pipeline/__tests__/cognitive-pipeline.test.ts

@@ -61,48 +61,48 @@ function makeReadStage(): ReadStage<FakeTrace, FakeAnswer> {
 describe('CognitivePipeline: ingest stage', () => {
   it('forwards content to the configured IngestStage', async () => {
     const ingest = makeIngestStage();
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({ ingest });
-    const result = await guardrails.ingest('hello');
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({ ingest });
+    const result = await pipeline.ingest('hello');
     expect(ingest.ingest).toHaveBeenCalledWith('hello', undefined);
     expect(result.writtenTraces).toBe(1);
   });
 
   it('throws when ingest is called without an IngestStage', async () => {
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({});
-    await expect(guardrails.ingest('hello')).rejects.toThrow(/IngestStage/);
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({});
+    await expect(pipeline.ingest('hello')).rejects.toThrow(/IngestStage/);
   });
 });
 
 describe('CognitivePipeline: recall stage', () => {
   it('forwards query to the configured RecallStage', async () => {
     const recall = makeRecallStage();
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({ recall });
-    const result = await guardrails.recall('what is X?');
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({ recall });
+    const result = await pipeline.recall('what is X?');
     expect(recall.recall).toHaveBeenCalledWith('what is X?', undefined);
     expect(result.traces).toHaveLength(2);
     expect(result.backend).toBe('canonical-hybrid');
   });
 
   it('throws when recall is called without a RecallStage', async () => {
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({});
-    await expect(guardrails.recall('q')).rejects.toThrow(/RecallStage/);
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({});
+    await expect(pipeline.recall('q')).rejects.toThrow(/RecallStage/);
   });
 });
 
 describe('CognitivePipeline: read stage', () => {
   it('forwards query+traces to the configured ReadStage', async () => {
     const read = makeReadStage();
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({ read });
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({ read });
     const traces: FakeTrace[] = [{ id: 't1', text: 'e' }];
-    const result = await guardrails.read('q?', traces);
+    const result = await pipeline.read('q?', traces);
     expect(read.read).toHaveBeenCalledWith('q?', traces, undefined);
     expect(result.outcome.answer).toBe('answered: q?');
   });
 
   it('throws when read is called without a ReadStage', async () => {
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({});
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({});
     await expect(
-      guardrails.read('q?', []),
+      pipeline.read('q?', []),
     ).rejects.toThrow(/ReadStage/);
   });
 });
@@ -111,12 +111,12 @@ describe('CognitivePipeline: end-to-end recallAndRead', () => {
   it('chains recall + read in one call and returns full telemetry', async () => {
     const recall = makeRecallStage();
     const read = makeReadStage();
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({
       recall,
       read,
     });
 
-    const result = await guardrails.recallAndRead('what is X?');
+    const result = await pipeline.recallAndRead('what is X?');
 
     expect(recall.recall).toHaveBeenCalledTimes(1);
     expect(read.read).toHaveBeenCalledTimes(1);
@@ -128,17 +128,17 @@ describe('CognitivePipeline: end-to-end recallAndRead', () => {
   });
 
   it('throws on recallAndRead when recall stage is missing', async () => {
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({
       read: makeReadStage(),
     });
-    await expect(guardrails.recallAndRead('q')).rejects.toThrow(/RecallStage/);
+    await expect(pipeline.recallAndRead('q')).rejects.toThrow(/RecallStage/);
   });
 
   it('throws on recallAndRead when read stage is missing', async () => {
-    const guardrails = new CognitivePipeline<FakeTrace, FakeAnswer>({
+    const pipeline = new CognitivePipeline<FakeTrace, FakeAnswer>({
       recall: makeRecallStage(),
     });
-    await expect(guardrails.recallAndRead('q')).rejects.toThrow(/ReadStage/);
+    await expect(pipeline.recallAndRead('q')).rejects.toThrow(/ReadStage/);
   });
 });
 

src/ingest-router/IngestRouter.ts

@@ -4,8 +4,8 @@
  * ingest classifier and the pure {@link selectIngestStrategy} into a
  * single per-content routing call.
  *
- * Same shape as MemoryRouter (recall-stage) so the multi-stage guardrails
- * orchestrator can compose them uniformly. Decide-only and decide+dispatch
+ * Same shape as MemoryRouter (recall-stage) so Cognitive Pipeline can
+ * compose them uniformly. Decide-only and decide+dispatch
  * flows are both supported.
  *
  * @module @framers/agentos/ingest-router/IngestRouter

src/ingest-router/classifier.ts

@@ -3,9 +3,8 @@
  * @description LLM-as-judge classifier that maps a piece of content to
  * one of the six {@link IngestContentKind} values.
  *
- * Same shape as the memory-router classifier — deliberately so the
- * multi-stage guardrails orchestrator can compose them with one mental
- * model.
+ * Same shape as the memory-router classifier, deliberately so Cognitive
+ * Pipeline can compose them with one mental model.
  *
  * @module @framers/agentos/ingest-router/classifier
  */

src/ingest-router/index.ts

@@ -2,9 +2,9 @@
  * AgentOS IngestRouter Module
  *
  * Input-stage LLM-as-judge orchestrator for memory ingest. Sibling of
- * {@link MemoryRouter} (recall-stage), {@link QueryRouter} (Q&A-stage),
- * and the output-stage guardrails. Together they form the agentos
- * multi-stage guardrails pattern.
+ * {@link MemoryRouter} (recall-stage) and {@link QueryRouter} (Q&A-stage).
+ * IngestRouter is the first stage in the agentos Cognitive Pipeline
+ * pattern; output-stage guardrails remain a separate downstream concern.
  *
  * Where MemoryRouter picks the recall architecture for a query,
  * IngestRouter picks the storage architecture for incoming content. The

src/ingest-router/select-strategy.ts

@@ -4,8 +4,8 @@
  * predicted content kind + routing table + budget policy.
  *
  * Stateless. Deterministic. No I/O. Same shape as
- * {@link selectBackend} in memory-router so the multi-stage guardrails
- * orchestrator can compose them uniformly.
+ * {@link selectBackend} in memory-router so Cognitive Pipeline can compose
+ * them uniformly.
  *
  * @module @framers/agentos/ingest-router/select-strategy
  */

src/memory-router/README.md

@@ -250,7 +250,7 @@ Calibrating your own cost-points takes one sweep per backend across a representa
 
 - `@framers/agentos/query-router` — general Q&A routing (vector search / graph / keyword). Sibling primitive; different use case (ask-a-question vs recall-past-context).
 - `@framers/agentos/memory` — the underlying Memory + HybridRetriever + SessionRetriever primitives the canonical-hybrid backend calls.
-- `@framers/agentos/core/guardrails` — output-stage guardrails. MemoryRouter is the input-stage guardrail that picks architecture; core/guardrails validate the output.
+- `@framers/agentos/core/guardrails` — output-stage guardrails. MemoryRouter is the recall-stage orchestrator that picks architecture; core/guardrails validate the output.
 - `@framers/agentos-ext-grounding-guard` — output-stage grounding judge for retrieved-evidence-backed answers.
 
-Together, these form the multi-stage guardrails pattern: `ingest → memory-router → retrieve → read → core/guardrails + grounding-guard`. Each stage is an LLM-as-judge decision point with its own interface.
+Together, the router stages form the Cognitive Pipeline pattern: `ingest-router → memory-router → read-router`. The ingest, recall, and read stages are LLM-as-judge orchestration points with their own interfaces. In a full app, `core/guardrails` and `agentos-ext-grounding-guard` run downstream as safety/policy validators.