InfraFabric — Anthropic addendum (system explainer)

Danny Stocker
Anthropic Fellowship Submission – January 2026
Track: AI Safety / Safety Engineering
(Safety / Security – Runtime Governance & Verifiable Oversight)
danny.stocker@gmail.com | ds@infrafabric.io | +33 6 52 48 90 17

Document 02 of 03
Architecture (dependency graphs + module map; ~20 min)
Reading order: 01 (evidence) → 02 (you are here) → 03 (optional narrative)
Prerequisite: read Document 01 first (and run “Proof in 60 seconds” if you want a quick integrity check).
Meta-note: Document 01 contains a factual `if.knowledge` disclosure (v1 docs pipeline + v2 concept graph; task-board timestamps).

Project homepage
https://infrafabric.io

LLM review access (task board, session ledger, registry)
https://infrafabric.io/llm/

Document
02_InfraFabric-System-Explainer-2026012-0600CET

A system map with receipts: fewer vibes, more verifiable bytes.

Generated (UTC): 2026-01-12T05-17-58Z · Author: Danny Stocker (InfraFabric) · Single-file HTML · No browser login required

How to read this (black/white)

Receipts for integrity; skepticism for everything else.

This document is designed for reviewers in restrictive environments.

Intro (A/B)

Two tones, one constraint: if it can’t be audited, it doesn’t count.

Two tone variants for the same system: both are black/white and registry-driven.

Intro A (plain)

For the meeting minutes: plain words, fewer loopholes.

InfraFabric is a set of products/modules designed to make outputs and decisions legible to non-experts. The core posture is simple: when an output matters, publish an artifact that third parties can verify without accounts. Integrity (bytes match the hash) is verifiable; truth, correctness, compliance, safety, and intent are not implied.

This single-file addendum is a navigation and context layer: it maps products from the registry, shows a dependency graph, and embeds the relevant review-pack text so reviewers aren’t blocked by link failures.

Intro B (direct)

For the war room: blunt words, same constraints.

The point is not to ship more pages. The point is to ship fewer lies. If a system can’t be audited by a nurse or a farmer, it isn’t constitutional “for the subjects” — it’s just another black box with better marketing.

InfraFabric treats verification as a product surface: publish artifacts, prove integrity without logins, preserve dissent and constraints, and make it cheap for reviewers to say “yes” or “no” based on evidence, not vibes.

Entry points (one URL per line)

No scavenger hunt: here are the doors.

https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v6.2/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/index.html
https://infrafabric.io/llm/
https://infrafabric.io/llm/if.registry.json
https://infrafabric.io/llm/task-board.html
https://infrafabric.io/llm/session-state.html
https://infrafabric.io/static/hosted/evidence/index.html

Product tree

If we can’t point to the URL, it’s a rumor, not a surface.

Public + reviewer surfaces. Some registry SKU paths are not deployed pages yet.

infrafabric.io
├── /if
│   ├── gov/   (if.gov; preview; product)
│   │   └── council/   (if.gov.council; roadmap; sku)
│   │   └── council/extended/   (if.gov.council.extended; roadmap; sku)
│   │   └── triage/   (if.gov.triage; roadmap; sku)
│   ├── trace/   (if.trace; shipped; product)
│   ├── security/   (if.security; roadmap; module)
│   │   └── secrets/detect/   (if.security.secrets.detect; preview; module)
│   ├── bus/   (if.bus; roadmap; product)
│   ├── api/   (if.api; roadmap; product)
│   ├── emotion/   (if.emotion; preview; product)
│   ├── typeset/   (if.typeset; preview; product)
│   ├── kb/   (if.kb; preview; module)
│   ├── knowledge/   (if.knowledge; roadmap; module)
│   ├── story/   (if.story; roadmap; module)
│   ├── search/   (if.search; roadmap; module)
│   ├── intelligence/   (if.intelligence; roadmap; module)
│   └── swarm/   (if.swarm; roadmap; module)
├── /review
│   └── shadowrt/   (if.shadowrt; shipped; surface)
├── /llm
│   ├── if.registry.json
│   ├── task-board.html
│   ├── session-state.html
│   └── products/
│       ├── if-api/
│       ├── if-bus/
│       ├── if-emotion/
│       ├── if-gov/
│       ├── if-intelligence/
│       ├── if-kb/
│       ├── if-knowledge/
│       ├── if-search/
│       ├── if-security/
│       ├── if-story/
│       ├── if-swarm/
│       ├── if-trace/
│       └── if-typeset/
└── /static/hosted/review
    └── infrafabric-anthropic-addendum/
        └── 2026-01-11/
            ├── index.html (v5; single-file)
            └── v6.2/index.html (this doc)

Conceptual stack (Graphviz)

The trust stack: contracts up top, receipts underneath, excuses nowhere.

Design-intent diagram (not a registry dependency graph).

if_concept_stack cluster_decision Decision contracts cluster_integrity Integrity + posture cluster_transport Transport + integration cluster_support Supporting surfaces if.gov if.gov if.trace if.trace if.gov->if.trace bind packs to receipts if.security if.security if.gov->if.security evidence posture + actuation gates if.bus if.bus if.bus->if.trace receipt-bind outputs if.bus->if.security security_signal posture if.api if.api if.api->if.bus adapters (envelopes) if.shadowrt if.shadowrt if.shadowrt->if.trace publishes / routes to receipts if.typeset if.typeset if.typeset->if.trace review packs / deterministic docs if.emotion if.emotion if.story if.story if.knowledge if.knowledge if.kb if.kb if.knowledge->if.kb build-time generation if.search if.search if.intelligence if.intelligence if.swarm if.swarm if.security.secrets.detect if.security secrets.detect
Graphviz DOT source (conceptual stack)
digraph if_concept_stack {
  rankdir=TB;
  graph [bgcolor="transparent", pad="0.2", nodesep="0.35", ranksep="0.55", fontname="Inter,Arial"];
  node [shape=box, style="rounded,filled", fontname="Inter,Arial", fontsize=12, color="#2d3748", penwidth=1, fillcolor="#f7fafc"];
  edge [color="#4a5568", arrowsize=0.7, penwidth=1, fontname="Inter,Arial", fontsize=10];

  subgraph cluster_decision {
    label="Decision contracts";
    color="#e2e8f0";
    style="rounded";
    "if.gov" [fillcolor="#bee3f8"];
  }

  subgraph cluster_integrity {
    label="Integrity + posture";
    color="#e2e8f0";
    style="rounded";
    "if.trace" [fillcolor="#c6f6d5"];
    "if.security" [fillcolor="#edf2f7"];
  }

  subgraph cluster_transport {
    label="Transport + integration";
    color="#e2e8f0";
    style="rounded";
    "if.bus" [fillcolor="#edf2f7"];
    "if.api" [fillcolor="#edf2f7"];
  }

  subgraph cluster_support {
    label="Supporting surfaces";
    color="#e2e8f0";
    style="rounded";
    "if.shadowrt";
    "if.typeset" [fillcolor="#bee3f8"];
    "if.emotion" [fillcolor="#bee3f8"];
    "if.story";
    "if.knowledge";
    "if.kb" [fillcolor="#bee3f8"];
    "if.search";
    "if.intelligence";
    "if.swarm";
    "if.security.secrets.detect" [fillcolor="#bee3f8", label="if.security\nsecrets.detect"];
  }

  // Conceptual edges (design intent). These are not registry dependencies.
  "if.gov" -> "if.trace" [style=dashed, label="bind packs to receipts"];
  "if.gov" -> "if.security" [style=dashed, label="evidence posture + actuation gates"];

  "if.bus" -> "if.trace" [style=dashed, label="receipt-bind outputs"];
  "if.bus" -> "if.security" [style=dashed, label="security_signal posture"];
  "if.api" -> "if.bus" [style=dashed, label="adapters (envelopes)"];

  "if.shadowrt" -> "if.trace" [style=dashed, label="publishes / routes to receipts"];
  "if.typeset" -> "if.trace" [style=dashed, label="review packs / deterministic docs"];
  "if.knowledge" -> "if.kb" [style=dashed, label="build-time generation"];
}

Dependency graph (Graphviz; registry-derived)

Because dependencies don’t care about your slide deck.

This graph uses only registry uses_receipts_from edges.

if_registry cluster_core core cluster_support supporting modules cluster_gov_skus if.gov SKUs (registry entries) cluster_legend legend if.gov if.gov if.trace if.trace if.gov->if.trace uses_receipts_from if.security if.security if.security->if.trace uses_receipts_from if.bus if.bus if.api if.api if.shadowrt if.shadowrt if.shadowrt->if.trace uses_receipts_from if.search if.search if.search->if.trace uses_receipts_from if.intelligence if.intelligence if.intelligence->if.trace uses_receipts_from if.swarm if.swarm if.swarm->if.trace uses_receipts_from if.story if.story if.story->if.trace uses_receipts_from if.knowledge if.knowledge if.knowledge->if.trace uses_receipts_from if.kb if.kb if.kb->if.trace uses_receipts_from if.typeset if.typeset if.security.secrets.detect if.security.secrets.detect if.security.secrets.detect->if.trace uses_receipts_from if.emotion if.emotion if.emotion->if.trace uses_receipts_from if.gov.triage if.gov.triage if.gov.triage->if.trace uses_receipts_from if.gov.council if.gov.council if.gov.council->if.trace uses_receipts_from if.gov.council.extended if.gov.council.extended if.gov.council.extended->if.trace uses_receipts_from legend_shipped shipped legend_preview preview legend_roadmap roadmap
Graphviz DOT source (registry-derived)
digraph if_registry {
  rankdir=LR;
  graph [bgcolor="transparent", pad="0.2", nodesep="0.25", ranksep="0.45", fontname="Inter,Arial"];
  node [shape=box, style="rounded,filled", fontname="Inter,Arial", fontsize=11, color="#2d3748", penwidth=1];
  edge [color="#718096", arrowsize=0.7, penwidth=1];
  subgraph cluster_core {
    label="core";
    color="#e2e8f0";
    style="rounded";
    "if.gov" [fillcolor="#bee3f8", tooltip="preview product"];
    "if.trace" [fillcolor="#c6f6d5", tooltip="shipped product"];
    "if.security" [fillcolor="#edf2f7", tooltip="roadmap module"];
    "if.bus" [fillcolor="#edf2f7", tooltip="roadmap product"];
    "if.api" [fillcolor="#edf2f7", tooltip="roadmap product"];
  }
  subgraph cluster_support {
    label="supporting modules";
    color="#e2e8f0";
    style="rounded";
    "if.shadowrt" [fillcolor="#c6f6d5", tooltip="shipped surface"];
    "if.search" [fillcolor="#edf2f7", tooltip="roadmap module"];
    "if.intelligence" [fillcolor="#edf2f7", tooltip="roadmap module"];
    "if.swarm" [fillcolor="#edf2f7", tooltip="roadmap module"];
    "if.story" [fillcolor="#edf2f7", tooltip="roadmap module"];
    "if.knowledge" [fillcolor="#edf2f7", tooltip="roadmap module"];
    "if.kb" [fillcolor="#bee3f8", tooltip="preview module"];
    "if.typeset" [fillcolor="#bee3f8", tooltip="preview product"];
    "if.security.secrets.detect" [fillcolor="#bee3f8", tooltip="preview module"];
    "if.emotion" [fillcolor="#bee3f8", tooltip="preview product"];
  }
  subgraph cluster_gov_skus {
    label="if.gov SKUs (registry entries)";
    color="#e2e8f0";
    style="rounded";
    "if.gov.triage" [fillcolor="#edf2f7"];
    "if.gov.council" [fillcolor="#edf2f7"];
    "if.gov.council.extended" [fillcolor="#edf2f7"];
  }
  "if.shadowrt" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.search" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.intelligence" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.swarm" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.story" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.knowledge" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.kb" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.gov" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.gov.triage" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.gov.council" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.gov.council.extended" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.security" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.security.secrets.detect" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  "if.emotion" -> "if.trace" [label="uses_receipts_from", fontsize=9, fontcolor="#4a5568"];
  subgraph cluster_legend {
    label="legend";
    color="#e2e8f0";
    style="rounded";
    "legend_shipped" [label="shipped", fillcolor="#c6f6d5"];
    "legend_preview" [label="preview", fillcolor="#bee3f8"];
    "legend_roadmap" [label="roadmap", fillcolor="#edf2f7"];
    "legend_shipped" -> "legend_preview" [style=invis];
    "legend_preview" -> "legend_roadmap" [style=invis];
  }
}

Security posture (why so much?)

Security is expensive; breach optics are a subscription you can’t cancel.

Security isn’t a tax; it’s a seatbelt. It is insurance against silent failure: it reduces likelihood and blast radius, and makes incidents auditable rather than invisible.

In InfraFabric terms: when something goes wrong, the system should emit structured signals, preserve decision context, and produce artifacts that can be verified without privileged access.

Products and modules (registry-driven)

Meet the cast: shipped, preview, roadmap — and none secured by adjectives.

Gov-first ordering; each section includes Who/Why/What/Where/When/How and embedded review-pack text when available.

if.gov preview product

Governance as files: boring on purpose, auditable by default.

path /if/gov

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Decision owners and reviewers who need audit-ready outputs that remain verifiable years later (without trusting a specific model).

Why does it exist?

Because “we meant well” isn’t an audit trail.

Make decisions reproducible: structured inputs + evidence links + deterministic checks where possible; optional LLM drafting is treated as untrusted.

What is it?

Define the thing, then we can argue about it.

Decision-pack contracts (preview demos) + governance seat models (design target).

Where does it live?

No URL, no audit — just vibes.

Public product page + decision-pack demo + council seats pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Preview: demo packs exist; the multi-tier SKUs are registry entries (roadmap) and do not have deployed pages yet.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Emit a decision pack as files; bind integrity to if.trace receipts; treat actuation gating as an evidence-typed design target (defined in if.security posture).

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/gov/
https://infrafabric.io/llm/products/if-gov/

Cost posture (token burn → deterministic)

Tokens are a budget line item, not a personality trait.

Portfolio-style seats are useful if (and only if) they are a progressive engineering path: start with structured outputs, then replace expensive simulation with deterministic checkers. The goal state is reproducible governance with minimal or zero token cost.

Numbers below are illustrative heuristics (not measured on this host):

PhaseLLM usageTypical token profileGoal
1 (bootstrap)LLM-heavy~5–20 seats; structured JSON outputsCollect decision data + failure modes
2 (structured)LLM + validationSchema-linted seat outputsReduce sprawl; increase determinism
3 (hybrid)Checkers gate actuationLLM only for narrative draftsLower cost; higher auditability
4 (deterministic)Optional0 required tokensReproducible decisions without model lock-in
Embedded LLM review pack content

if.gov — review pack

Governance, bundled: what we claim, what we can prove, and where to poke holes.

product_id if.gov status preview updated 2026-01-11

What it is (plain)

The job description, minus the marketing.

  • if.gov is governance-as-a-pack: triage and decision packs designed for adversarial review.
  • Purpose make decisions checkable later: explicit assumptions, risks, controls, deltas, and evidence links.
  • Receipt-bound outputs can be bound to if.trace so third parties can verify bytes without logins.

SKUs

Pick the scope; the accountability stays.

  • if.gov.triage deliberation target: milliseconds (status: roadmap)
  • if.gov.council deliberation target: milliseconds (status: roadmap)
  • if.gov.council.extended deliberation target: adaptive ms → minutes (status: roadmap)
Note: the SKU naming exists in the registry; the public demo evidence below currently covers the decision-pack shape. Treat the SKUs as spec-level until standalone demo packs exist.

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Receipts prove integrity: the bytes you download match the receipt hashes (and signatures only where present and verifiable).
  • Receipts do not prove compliance, policy effectiveness, safety, or factual correctness.
  • if.gov adds structured decision framing: scope, assumptions, risks, controls, and deltas — packaged for third-party critique.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

What’s missing (to ship the SKUs)

Specs are cheap; shipping is the tax.

  • Seat templates standardized seat charters + triggers + required artifacts.
  • Schemas transcript/vote/research artifact schemas that can be verified and diffed.
  • Reference runner runnable reference implementation for the pack lifecycle.
  • Standalone demos separate public demo packs for triage/council/extended (HTML-first, receipt-bound).

Review questions (what we want from you)

Attack the claims, not the people.

  • Sellability is the “decision pack” deliverable buyable, and by whom?
  • Assumptions which parts would fail in real procurement / audit workflows?
  • Contrarian critique what’s the simplest wedge that gets paid?
  • Diffs if you’d change the pack structure, propose unified diffs.

Back

Back to the map; don’t let the appendix eat the narrative.

if.trace shipped product

Trust is optional; hashes are not.

path /if/trace

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Anyone who must verify byte integrity without accounts: auditors, partners, journalists, regulators, internal teams.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Give third parties a no-login way to verify: do the bytes match the public hash (and signature, when present and verifiable)?

What is it?

Define the thing, then we can argue about it.

Public receipt surface + offline verifier tooling; integrity proofs, not truth proofs.

Where does it live?

No URL, no audit — just vibes.

Product page + live receipt surface + offline verifier.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Shipped surface on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Publish a receipt with hashes; later anyone downloads and checks sha256 matches; use QUANTUM READY only when a PQ receipt exists.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/trace/
https://infrafabric.io/llm/products/if-trace/
Embedded LLM review pack content

if.trace — review pack

Trust is optional; hash checks are not.

product_id if.trace status shipped updated 2026-01-06

What it is (plain)

The job description, minus the marketing.

  • if.trace is a public, no-login receipt surface that binds source_sha256 ↔ output_sha256 to a stable shareId.
  • Purpose prove byte integrity across handoffs (email, tickets, vendors, auditors) without granting internal access.

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Receipts prove the bytes you download match the hashes on the receipt (and signatures only when present and verifiable).
  • Receipts do not prove factual correctness, compliance, safety, intent, or “no hallucinations”.
  • Practical wedge you can prove the AI output (or PDF) you reviewed is exactly the one that shipped.
  • QUANTUM READY means: a post-quantum signature receipt exists for the trace; it is not a claim of quantum security.

Fast verify (60 seconds)

Set a timer, check the hash, move on.

  1. Open a receipt and copy output_sha256.
  2. Download the output you are checking (pack or dossier) and hash it locally.
  3. Compare hashes. If one character changes, the hash changes and verification fails.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Receipt surfaces (canonical)

These are the URLs that keep their promises.

Example (known-good demo):

Offline verification (bundles)

For air-gapped skeptics: same receipts, fewer assumptions.

Related surfaces

Nice-to-have context, not required faith.

Review questions (what we want from you)

Attack the claims, not the people.

  • UX is the receipt page enough for a third-party to verify in 60 seconds?
  • Truth claims is black/white wording strict enough (integrity only)?
  • Pricing do retention/privacy/SLA/volume knobs map to value?
  • Threat model does this cover adversarial reality (insider edits, external tampering, handoff drift) without overclaiming?

Back

Back to the map; don’t let the appendix eat the narrative.

if.security roadmap module

Security posture: rules we can point to before the incident.

path /if/security

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Builders who need a consistent, cross-cutting security posture across modules (not bespoke per product).

Why does it exist?

Because “we meant well” isn’t an audit trail.

Security isn’t a tax; it’s a seatbelt. It’s insurance against silent failure: it reduces likelihood and blast radius, and makes incidents auditable.

What is it?

Define the thing, then we can argue about it.

Cross-cutting posture doc (roadmap): evidence typing, containment levels, and how modules emit/consume security signals.

Where does it live?

No URL, no audit — just vibes.

Public module page + posture snapshot pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: posture exists; enforcement is a design target implemented module-by-module.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Standardize security signals, define evidence posture + actuation gates, and map containment actions onto module control planes.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/security/
https://infrafabric.io/llm/products/if-security/
Embedded LLM review pack content

if.security — review pack

Posture before panic: boundaries, threat model, and receipts-friendly evidence.

product_id if.security status roadmap updated 2026-01-11

What it is (plain)

The job description, minus the marketing.

  • if.security is the cross-cutting posture for how modules describe security-relevant findings without over-claiming.
  • Primitive the shared atomic unit is if.bus.security_signal (redacted; public-safe).
  • Actuation posture containment reuses if.bus control-plane commands; high-impact actions can escalate to if.gov.

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Verified a posture doc + schemas can be reviewed and diffed (static artifacts).
  • Not claimed a deployed security runtime exists on this host.
  • Receipts prove integrity (hash match), not truth, correctness, safety, or compliance.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions (what we want from you)

Attack the claims, not the people.

  • Minimum is if.bus.security_signal sufficient, or is a second schema required for security actions?
  • Automation what would you require before allowing automated CONTAIN/HALT actions on a bus control plane?
  • Scope what is the smallest security posture that is still worth adopting across modules?

Back

Back to the map; don’t let the appendix eat the narrative.

if.bus roadmap product

Make the safe path the easy path, or nobody takes it.

path /if/bus

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Platform/integration teams who want integrations to be boring: one envelope, predictable outputs, auditable failure modes.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Make the compliant path the easy path: budgets, security signals, DLQ, replay controls, and receipt binding are part of the contract.

What is it?

Define the thing, then we can argue about it.

Transport-agnostic bus contract (roadmap) + runtime spec and sandbox artifacts.

Where does it live?

No URL, no audit — just vibes.

Product page + whitepaper + runtime spec + sandbox pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: architecture/specs + sandbox exist; not shipped as a shared live bus service on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Stable envelope schema; separate data-plane from control-plane; implement transport adapters (in_memory / NATS JetStream reference).

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/bus/
https://infrafabric.io/llm/products/if-bus/
Embedded LLM review pack content

if.bus — review pack

Make compliance the easy path, then ship the pipes.

product_id if.bus status roadmap updated 2026-01-11

What it is (plain)

The job description, minus the marketing.

  • if.bus is the integration backbone: normalize events, route them, and make outputs verifiable by default.
  • Two-way street inbound webhooks and outbound actions flow through the same envelope (via if.api adapters).
  • Status architecture exists; not shipped as a runnable bus on the current single-host deployment.

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim a bus makes integrations boring: one adapter per system, one envelope, predictable outputs.
  • Verification outputs can be bound to if.trace receipts (integrity only).
  • Not claimed a live deployed bus service exists (unless a runnable demo is linked).

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

What’s missing (to ship)

The gap list: where roadmap meets reality.

  • Contracts canonical envelope schema + versioning policy.
  • Adapters shipped if.api adapters for at least 2–3 real systems.
  • Runnable demo end-to-end bus demo (ingress → route → output) with receipt-backed artifacts.
  • Ops story rate limiting, replay protection, and failure-mode clarity.

Review questions (what we want from you)

Attack the claims, not the people.

  • Wedge is the “integration backbone” story compelling without a running demo?
  • Buyer who pays for this: platform teams, security, compliance, product ops?
  • Simplicity what’s the minimum bus that is still worth buying?

Back

Back to the map; don’t let the appendix eat the narrative.

if.api roadmap product

APIs as contracts: fewer surprises, more receipts.

path /if/api

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Teams integrating external systems who want adapters to be deterministic, reviewable, and inventory-tracked.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Stop bespoke glue code: normalize webhooks/actions into a shared envelope and keep a public integration inventory.

What is it?

Define the thing, then we can argue about it.

Adapter/integration layer (roadmap) with demo artifacts where available.

Where does it live?

No URL, no audit — just vibes.

Product page + integrations inventory + demo packs.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: demos and inventories exist; not shipped as a general-purpose runtime adapter service.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Adapters transform provider payloads to/from if.bus envelopes; demos publish reproducible bundles.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/api/
https://infrafabric.io/llm/products/if-api/
Embedded LLM review pack content

if.api — review pack

APIs as contracts: fewer surprises, more audit trails.

product_id if.api status roadmap updated 2026-01-10

What it is (plain)

The job description, minus the marketing.

  • if.api is an integration inventory + adapter concept for external APIs (webhooks in; actions out).
  • Purpose make integrations repeatable: stable contracts, predictable transforms, and fewer “one-off scripts”.
  • Status public artifacts exist; not shipped as a general-purpose integration runtime on the current host.

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim adapters should be boring: one per system, mapped to a shared envelope.
  • Verification demo outputs can be bound to if.trace receipts (integrity only).
  • Not claimed a comprehensive adapter library exists today.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

What’s missing (to ship)

The gap list: where roadmap meets reality.

  • Adapter quality bar “official” adapter criteria (schema/versioning/error contracts).
  • Coverage initial 2–3 core systems end-to-end (GitHub/Jira/Slack etc.).
  • Runtime a stable adapter runner with retries, replay protection, and audit logs.

Review questions (what we want from you)

Attack the claims, not the people.

  • Buyer is this owned by platform, product ops, security, or compliance?
  • Simplicity what’s the smallest integration library worth paying for?
  • Positioning should this be sold as “inventory + contracts” first, before runtime?

Back

Back to the map; don’t let the appendix eat the narrative.

if.emotion preview product

High-stakes domain: we’d rather be cautious than clever.

path /if/emotion

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Product and governance builders needing wellbeing-aware outputs with explicit safety boundaries.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Sensitive UX requires auditability and clear non-clinical boundaries.

What is it?

Define the thing, then we can argue about it.

Wellbeing-aware interaction layer and governance-seat outputs (preview).

Where does it live?

No URL, no audit — just vibes.

Review hub + evidence index + receipts (when published).

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Preview: boundary posture exists; deeper demos should remain explicitly non-clinical.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Bind outputs to receipts when publishing; keep claims black/white (integrity vs interpretation).

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/emotion/
https://infrafabric.io/llm/products/if-emotion/
Embedded LLM review pack content

if.emotion — review pack

High-stakes domain: scope, safety boundary, and evidence first.

product_id if.emotion status preview updated 2026-01-06

What it is (plain)

The job description, minus the marketing.

  • if.emotion is a wellbeing-aware interaction layer and governance-seat output layer with explicit safety boundaries.
  • Purpose make sensitive UX and governance outputs audit-ready (what was shown, what changed, what was decided) without drifting into clinical claims.

Black / white (safety boundary)

Safety boundary: what we do, what we refuse, and what we won’t pretend.

  • Not clinical this is not diagnosis, therapy, or crisis services.
  • Verified (when receipt-backed) integrity of published outputs via if.trace (bytes, not correctness).
  • Not verified mental health outcomes, safety guarantees, or correctness of interpretation.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

What’s missing (to ship cleanly)

The last mile is where good intentions go to get linted.

  • Claims truth table approved vs disallowed phrases for public docs and UI (no clinical drift).
  • Receipt-backed demo a sanitized, explicitly non-clinical demo pack bound to an if.trace receipt.
  • Consent + data boundaries explicit data-handling modes and redaction rules for any published artifacts.

Review questions (what we want from you)

Attack the claims, not the people.

  • Safety is the boundary clear enough to avoid accidental clinical claims?
  • Value who buys this, and why (governance teams, org wellbeing, product safety)?
  • Proof story what would a third party need to verify (and what should never be published)?

Back

Back to the map; don’t let the appendix eat the narrative.

if.typeset preview product

Reproducible documents: fewer PDFs-as-folklore.

path /if/typeset

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Anyone shipping review packs who needs deterministic, repeatable document builds.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Make docs survive adversarial review: deterministic builds + lint gates + consistent packaging.

What is it?

Define the thing, then we can argue about it.

Deterministic doc pipeline (preview).

Where does it live?

No URL, no audit — just vibes.

Product page + review pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Preview: tooling exists and is used for hosted-static packs.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Lint → render → QA incidents → ship packs (HTML-first fallbacks).

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/typeset/
https://infrafabric.io/llm/products/if-typeset/
Embedded LLM review pack content

if.typeset — review pack

Turn documents into artifacts reviewers can actually verify.

product_id if.typeset status preview updated 2026-01-06

What it is (plain)

The job description, minus the marketing.

  • if.typeset is deterministic document CI: lint → render HTML/PDF → QA incidents → trust contract.
  • Purpose ship documents that survive scrutiny and remain reviewable months later.

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Verified deterministic builds and measured QA incidents (machine-readable outputs).
  • Not verified factual correctness, compliance, or “the narrative is true”.
  • Pairs with if.trace when you publish outputs for third parties to verify bytes without logins.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions (what we want from you)

Attack the claims, not the people.

  • DX is the demo pack self-explanatory for a third party?
  • Quality gates are the QA incidents meaningful and actionable?
  • Adoption what’s missing for teams to run this in CI with confidence?
  • Wedge is “scrutiny-proof publishing” a buyable problem statement?

Back

Back to the map; don’t let the appendix eat the narrative.

if.shadowrt shipped surface

Adversarial review as a surface: critique you can’t hand-wave away.

path /review/shadowrt

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Reviewers and publishers who need a navigable UI over receipt-backed artifacts.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Make review flows legible (dossiers/packs) while routing back to receipts.

What is it?

Define the thing, then we can argue about it.

Shipped review surface for browsing published artifacts.

Where does it live?

No URL, no audit — just vibes.

Public review surface.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Shipped surface on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Serves HTML-first review pages that link to stable no-login receipt URLs.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/review/shadowrt/
Embedded mini-pack (generated)

Black / white

Claims in black/white; anything else is marketing.

  • Verified registry status + published URLs (when present).
  • Not verified factual correctness, safety, compliance, or intent.

if.kb preview module

If knowledge isn’t findable, it’s not knowledge; it’s lore.

path /if/kb

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Developers and reviewers who need build-time, static knowledge base pages (no runtime fetches).

Why does it exist?

Because “we meant well” isn’t an audit trail.

Keep KBs consistent and versioned by generating them at build time.

What is it?

Define the thing, then we can argue about it.

Build-time KB artifacts (preview).

Where does it live?

No URL, no audit — just vibes.

Product page + KB spec pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Preview: KB snapshots exist.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Generate static Markdown/HTML from registry + config + schemas + templates.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/kb/
https://infrafabric.io/llm/products/if-kb/
Embedded LLM review pack content

if.kb — review pack

If you can’t find it, you can’t govern it.

product_id if.kb status preview updated 2026-01-11

What it is (plain)

The job description, minus the marketing.

  • Module if.kb is a build-time pipeline for generating static developer KB pages.
  • Inputs registry + schemas + config + template + snippet ranges.
  • Outputs static Markdown + hosted-static HTML wrapper (no runtime fetches).

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim registry + schema driven KBs reduce drift and keep reviewer links stable.
  • Verification posture KB pages are static artifacts; receipts (when referenced) prove byte integrity, not truth.
  • Not claimed a deployed if.kb runtime or live APIs on this host.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions

Be sharp: we can fix bugs, not flattery.

  • Contract should KB config files have an explicit JSON Schema (draft 2020-12) for validation?
  • Lint what should fail publish beyond registry + URL hygiene (secrets/PII, snippet bounds, forbidden wording)?
  • Scale should the KB builder be generalized to docs/data/*.json (multi-KB), or kept per product?

Back

Back to the map; don’t let the appendix eat the narrative.

if.knowledge roadmap module

The pack factory: turn scattered docs into reviewable bundles.

path /if/knowledge

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Maintainers who need deterministic, registry-driven documentation generation.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Reduce drift and manual copy-paste by generating docs from canonical inputs.

What is it?

Define the thing, then we can argue about it.

Build-time documentation pipeline (roadmap).

Where does it live?

No URL, no audit — just vibes.

Product page + spec pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: pipeline exists; expanded outputs iterate over time.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Parse registry + task board + templates to produce single-file review artifacts.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/knowledge/
https://infrafabric.io/llm/products/if-knowledge/
Embedded LLM review pack content

if.knowledge — review pack

The pack factory: generate review bundles without turning into a link farm.

product_id if.knowledge status roadmap updated 2026-01-11

What it is (plain)

The job description, minus the marketing.

  • Module if.knowledge is a build-time documentation pipeline (registry-driven).
  • Inputs registry + schemas + templates + deterministic generators.
  • Outputs static Markdown + hosted-static HTML wrappers (no runtime fetches).
  • Use produce reviewable artifacts quickly (specs, KB pages, and application addenda).

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim build-time generation reduces drift and keeps links stable for external review.
  • Verification posture outputs are static artifacts; receipts (when used) prove byte integrity, not truth or correctness.
  • Not claimed a deployed if.knowledge service, live APIs, or runtime data fetching on this host.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions

Be sharp: we can fix bugs, not flattery.

  • Addendum What should be included/excluded to keep the addendum evidence-based (no “vibes”)?
  • Drift Which lints should be publish-blocking beyond URL hygiene + registry alignment?
  • Scope Should if.knowledge remain a pipeline module or evolve into a general “knowledge graph” product?

Copy/paste bundle (one URL per line)

Clipboard-ready links; your reviewer bot will thank you.

https://infrafabric.io/if/knowledge/
https://infrafabric.io/llm/products/if-knowledge/
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/index.html
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/index.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/artifacts/spec/90-if-knowledge-spec.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/artifacts/scripts/build_if_knowledge_addendum.py
https://infrafabric.io/llm/products/if-knowledge/knowledge-spec/2026-01-11/artifacts/scripts/lint_if_knowledge_addendum.py
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/index.html
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/index.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/artifacts/spec/92-if-knowledge-graph-spec.md
https://infrafabric.io/llm/products/if-knowledge/knowledge-graph/2026-01-11/artifacts/data/if_knowledge_graph.v2.json
https://infrafabric.io/static/hosted/review/infrafabric-system-map/2026-01-11/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v1/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v2/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v3/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v4/index.html
https://infrafabric.io/static/hosted/review/infrafabric-anthropic-addendum/2026-01-11/v5/index.html
https://infrafabric.io/llm/if.registry.json

Back

Back to the map; don’t let the appendix eat the narrative.

if.story roadmap module

Narrative with guardrails: explain without hallucinating.

path /if/story

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Teams who need narrative logs that preserve the “why”, not just the “what”.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Bitmap snapshots lose reasoning; vector logs preserve constraints and rejected options.

What is it?

Define the thing, then we can argue about it.

Narrative logging protocol (roadmap).

Where does it live?

No URL, no audit — just vibes.

Product page + review pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: protocol spec exists.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Produce md+json artifacts with required metadata and lint rules.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/story/
https://infrafabric.io/llm/products/if-story/
Embedded LLM review pack content

if.story — review pack

Narrative is a tool; receipts are the seatbelt.

product_id if.story status roadmap updated 2026-01-11

What it is (plain)

The job description, minus the marketing.

  • Module if.story is a narrative logging protocol module (vector vs bitmap).
  • Goal preserve decision geometry (“why”), not just status snapshots (“what”).
  • Status roadmap (protocol note + example artifacts published; no receipt-backed demo and no deployed service).

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim narratives with explicit traps reduce regression and re-derivation failure over time.
  • Verification posture published artifacts can be bound to if.trace receipts to verify bytes without logins.
  • Not claimed factual correctness, safety, intent, or a deployed if.story runtime on this host.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions

Be sharp: we can fix bugs, not flattery.

  • Scope where should narrative logging be mandatory (controls, policy changes, decisions) vs optional?
  • Trap should “trap” be required in every narrative, or maintained as a separate stop-conditions artifact?
  • Lint what should fail publish (missing trap, missing evidence links, mixed URLs on one line, secrets leakage)?

Back

Back to the map; don’t let the appendix eat the narrative.

if.search roadmap module

Search as method: eight passes, fewer unforced errors.

path /if/search

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Investigators needing multi-pass, evidence-linked search workflows.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Turn research into a reproducible workflow (questions → sources → outputs).

What is it?

Define the thing, then we can argue about it.

Investigation/search workflow module (roadmap).

Where does it live?

No URL, no audit — just vibes.

Product page + review pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: no deployed service on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Define a multi-pass protocol and bind important outputs to receipts.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/search/
https://infrafabric.io/llm/products/if-search/
Embedded LLM review pack content

if.search — review pack

Methodology over magic: reduce unforced errors, then show your work.

product_id if.search status roadmap updated 2026-01-10

What it is (plain)

The job description, minus the marketing.

  • Module if.search is a pass-based investigation workflow (question → plan → evidence → synthesis).
  • Goal turn messy inputs into a traceable output that stays black/white about what is verified vs interpretation.
  • Status roadmap (receipt-backed demo exists; no deployed service).

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim a structured investigation flow reduces “one prompt” failure modes.
  • Verification when outputs matter, the design target is to bind output bytes to if.trace receipts.
  • Not claimed a shipped, deployed if.search service exists on this host.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions

Be sharp: we can fix bugs, not flattery.

  • Wedge what’s the simplest “investigation workflow” story that lands with non-technical reviewers?
  • Next demo what should the next receipt-backed demo prove (and what should it explicitly not claim)?
  • Outputs what output artifact shape would be most reviewable (JSON transcript, Markdown pack, both)?

Back

Back to the map; don’t let the appendix eat the narrative.

if.intelligence roadmap module

Signal over noise — and a place to be wrong in public.

path /if/intelligence

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Teams orchestrating evidence gathering and synthesis under strong auditability constraints.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Treat research as an auditable pipeline, not vibes.

What is it?

Define the thing, then we can argue about it.

Research orchestration module (roadmap).

Where does it live?

No URL, no audit — just vibes.

Product page + review pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: not a deployed service on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Coordinate searches, cite sources, and bind outputs to receipts when they matter.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/intelligence/
https://infrafabric.io/llm/products/if-intelligence/
Embedded LLM review pack content

if.intelligence — review pack

Signals, not vibes: keep the claims checkable.

product_id if.intelligence status roadmap updated 2026-01-10

What it is (plain)

The job description, minus the marketing.

  • Module if.intelligence is research orchestration: turn an inquiry into citations, constraints, and a readable answer.
  • Goal reduce “vibes” by grounding debate in evidence and clearly separating verified vs interpretation.
  • Status roadmap (receipt-backed demo exists; no deployed service).

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim research should be auditable: what sources were used, what was uncertain, what was assumed.
  • Verification when outputs matter, the design target is to bind output bytes to if.trace receipts.
  • Not claimed any specific live data access exists, or that outputs are “true” (unless independently verified and cited).

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions

Be sharp: we can fix bugs, not flattery.

  • Scope what should be “policy-gated” vs always allowed in an evidence workflow?
  • Outputs what artifact formats are easiest to review (citations table, transcript, executive memo)?
  • Failure modes what should fail closed vs fail open in research orchestration?

Back

Back to the map; don’t let the appendix eat the narrative.

if.swarm roadmap module

Many agents, one exit condition: evidence.

path /if/swarm

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Builders coordinating multiple agents/tools while keeping outputs traceable.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Multi-agent coordination needs a contract surface and auditability.

What is it?

Define the thing, then we can argue about it.

Multi-agent execution module (roadmap).

Where does it live?

No URL, no audit — just vibes.

Product page + review pack.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: not a deployed service on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Treat each agent/tool call as an auditable step, optionally receipt-bound.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/swarm/
https://infrafabric.io/llm/products/if-swarm/
Embedded LLM review pack content

if.swarm — review pack

Many perspectives, one bar: evidence you can hand to a stranger.

product_id if.swarm status roadmap updated 2026-01-10

What it is (plain)

The job description, minus the marketing.

  • Module if.swarm coordinates parallel work: scoped roles exchange bus envelopes and emit a transcript.
  • Goal make multi-agent execution reviewable: “what happened” is visible, not only the outcome.
  • Status roadmap (receipt-backed demo exists; no deployed service).

Black / white

Receipts prove bytes; they don’t prove virtue.

  • Claim coordination should use one envelope (if.bus) so work can be routed, replayed, and audited.
  • Verification when outputs matter, the design target is to bind output bytes to if.trace receipts.
  • Not claimed a deployed swarm runner exists on this host; the demo is a deterministic simulation only.

Evidence links (HTML-first)

If it needs a login, it’s not evidence; it’s theater.

Review questions

Be sharp: we can fix bugs, not flattery.

  • Outputs what transcript shape would make you trust the process (without trusting the model)?
  • Control what should be pausable/quarantinable/replayable by design?
  • Boundaries what should be banned by default (safety, policy, or operational risk)?

Back

Back to the map; don’t let the appendix eat the narrative.

if.security.secrets.detect preview module

Catch secrets in CI, not in headlines.

path /if/security/secrets/detect

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Teams who need secrets detection that is reviewable and safe to publish (redacted outputs).

Why does it exist?

Because “we meant well” isn’t an audit trail.

Prevent accidental leakage by detecting secrets before publishing artifacts.

What is it?

Define the thing, then we can argue about it.

Secrets detection module (preview; brand: if.yologuard).

Where does it live?

No URL, no audit — just vibes.

Public page + registry entry.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Preview: demo posture exists; outputs must stay redacted.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Scan inputs, emit security signals, and publish only redacted findings.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/security/secrets/detect/
Embedded mini-pack (generated)

Black / white

Claims in black/white; anything else is marketing.

  • Verified registry status + published URLs (when present).
  • Not verified factual correctness, safety, compliance, or intent.

if.gov.triage roadmap sku

Triage: fast decisions, explicit unknowns.

path /if/gov/triage

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Decision pipelines needing a fast preflight risk scan.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Catch obvious blockers early.

What is it?

Define the thing, then we can argue about it.

SKU design target (roadmap; registry entry).

Where does it live?

No URL, no audit — just vibes.

Included under if.gov specs/packs.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: registry SKU exists; no public /if/gov/triage page on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Input schema + deterministic checks where possible; outputs become part of a decision pack.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/gov/triage/
Embedded mini-pack (generated)

Black / white

Claims in black/white; anything else is marketing.

  • Verified registry status + published URLs (when present).
  • Not verified factual correctness, safety, compliance, or intent.

if.gov.council roadmap sku

Council: structured dissent, slower mistakes.

path /if/gov/council

Who is it for?

If you’re in this audience, you’re the one who gets paged.

High-stakes decisions needing multi-lens deliberation.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Capture dissent and make trade-offs auditable.

What is it?

Define the thing, then we can argue about it.

SKU design target (roadmap; registry entry).

Where does it live?

No URL, no audit — just vibes.

Included under if.gov specs/packs.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: registry SKU exists; no public /if/gov/council page on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Seat outputs are structured; deterministic checkers gate actuation (design target).

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/gov/council/
Embedded mini-pack (generated)

Black / white

Claims in black/white; anything else is marketing.

  • Verified registry status + published URLs (when present).
  • Not verified factual correctness, safety, compliance, or intent.

if.gov.council.extended roadmap sku

Extended: when the answer needs a checklist, not a vibe.

path /if/gov/council/extended

Who is it for?

If you’re in this audience, you’re the one who gets paged.

Decisions that need extra evidence gathering or external challenge.

Why does it exist?

Because “we meant well” isn’t an audit trail.

Make “go get more evidence” explicit rather than implicit.

What is it?

Define the thing, then we can argue about it.

SKU design target (roadmap; registry entry).

Where does it live?

No URL, no audit — just vibes.

Included under if.gov specs/packs.

When / readiness?

Status is a promise type: shipped > preview > roadmap.

Roadmap: registry SKU exists; no public /if/gov/council/extended page on this host.

How does it work (at a high level)?

Inputs, outputs, and where the receipts attach.

Extended workflow can allocate budget to evidence gathering, then re-run deterministic gates.

Review links (one URL per line)

Receipts aisle: grab what you need.

https://infrafabric.io/if/gov/council/extended/
Embedded mini-pack (generated)

Black / white

Claims in black/white; anything else is marketing.

  • Verified registry status + published URLs (when present).
  • Not verified factual correctness, safety, compliance, or intent.

Appendix: if.registry.json (embedded)

Source of truth beats source of vibes.

Canonical mirror is /llm/if.registry.json; embedded here for offline review.

Show registry JSON
{
  "version": 1,
  "updated_utc": "2026-01-11T19:17:11Z",
  "notes": [
    "This file is the canonical naming/slug registry. Do not hand-type product IDs, URL paths, or artifact slugs elsewhere.",
    "Brand labels are defined here (e.g., if.trace, IF.GOV). They may differ from product IDs.",
    "Receipts and manifests should always carry `product_id`; `brand` is the human-facing SKU label.",
    "Statuses are evidence levels (shipped/preview/roadmap); they do not imply customers, revenue, or multi-host reliability."
  ],
  "glossary": {
    "product_id": "Lowercase dot-namespace ID used in receipts/manifests and internal docs. This is the stable identifier.",
    "brand": "Human-facing SKU label. It can change without breaking receipts, as long as product_id stays stable.",
    "kind": "What this entry represents: a product, a surface (UI/distribution), a module (component), or a sku (deliverable tier).",
    "status": "Black/white evidence level (shipped/preview/roadmap). Status does not imply customers or revenue.",
    "path": "Canonical public URL path shape. Do not claim deployed unless verified; avoid dots in URL paths.",
    "slug": "Hyphenated artifact slug for filenames and page slugs.",
    "bundle_slug": "Hyphenated slug for demo bundles/artifacts.",
    "repo_dir": "Workspace-relative implementation directory (when applicable).",
    "vendored_engine_dir": "Workspace-relative path to an upstream/vendored engine used by a wrapper module (when applicable).",
    "uses_receipts_from": "If present, indicates which product_id provides the receipt surface used to bind outputs (e.g., if.trace)."
  },
  "status_definitions": {
    "shipped": {
      "means": "Public, no-login surface exists and is deployed; at least one real artifact is reviewable end-to-end.",
      "does_not_mean": [
        "paying customers exist",
        "multi-host reliability exists",
        "compliance guarantees",
        "factual correctness of narratives"
      ]
    },
    "preview": {
      "means": "Public demo artifacts exist (and can be reviewed), but the module/service is not yet treated as a live production surface.",
      "does_not_mean": [
        "paying customers exist",
        "CI/production integration is complete",
        "compliance guarantees"
      ]
    },
    "roadmap": {
      "means": "Concept/spec exists, but there is no public demo evidence that meets the reviewability bar.",
      "does_not_mean": [
        "deployed",
        "reviewable without internal access"
      ]
    }
  },
  "kind_definitions": {
    "product": "A sellable SKU/service concept with a canonical product_id.",
    "surface": "A UI/distribution surface that routes users to verification primitives (e.g., ShadowRT routes to if.trace receipts).",
    "module": "A component/module that can be integrated into workflows (e.g., CI scanners) and may publish receipt-backed outputs.",
    "sku": "A deliverable tier under a product (e.g., if.gov.triage)."
  },
  "products": [
    {
      "product_id": "if.trace",
      "brand": "if.trace",
      "kind": "product",
      "description": "Public receipt surface (hashes; signatures only when present and verifiable). Proof of bytes/integrity, not correctness.",
      "path": "/if/trace",
      "slug": "if-trace",
      "bundle_slug": "if-trace-demo-bundle",
      "status": "shipped"
    },
    {
      "product_id": "if.shadowrt",
      "brand": "ShadowRT",
      "kind": "surface",
      "description": "Publishing/review UI that makes if.trace legible via dossiers/packs and routes reviewers to receipts.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/review/shadowrt",
      "slug": "if-shadowrt",
      "bundle_slug": "if-shadowrt-demo-bundle",
      "status": "shipped"
    },
    {
      "product_id": "if.bus",
      "brand": "IF.bus",
      "kind": "product",
      "description": "Integration bus concept (message normalization + routing). Not shipped on the current host.",
      "path": "/if/bus",
      "slug": "if-bus",
      "bundle_slug": "if-bus-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.api",
      "brand": "IF.api (integrations)",
      "kind": "product",
      "description": "Integration inventory + adapters for external APIs. Not shipped as a runnable module on the current host.",
      "path": "/if/api",
      "slug": "if-api",
      "bundle_slug": "if-api-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.search",
      "brand": "if.search",
      "kind": "module",
      "description": "Multi-pass investigation/search workflow module (roadmap only; no receipt-backed demo published yet).",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/search",
      "slug": "if-search",
      "bundle_slug": "if-search-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.intelligence",
      "brand": "if.intelligence",
      "kind": "module",
      "description": "Research orchestration module (roadmap only; no receipt-backed demo published yet).",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/intelligence",
      "slug": "if-intelligence",
      "bundle_slug": "if-intelligence-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.swarm",
      "brand": "if.swarm",
      "kind": "module",
      "description": "Multi-agent/swarm execution module (roadmap only; no receipt-backed demo published yet).",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/swarm",
      "slug": "if-swarm",
      "bundle_slug": "if-swarm-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.story",
      "brand": "if.story",
      "kind": "module",
      "description": "Narrative logging protocol module (vector vs bitmap). Roadmap only; no receipt-backed demo published yet.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/story",
      "slug": "if-story",
      "bundle_slug": "if-story-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.knowledge",
      "brand": "if.knowledge",
      "kind": "module",
      "description": "Build-time documentation pipeline (registry-driven; static Markdown/HTML; no runtime fetches). Roadmap: no public demo artifacts published yet; no deployed service on this host.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/knowledge",
      "slug": "if-knowledge",
      "bundle_slug": "if-knowledge-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.kb",
      "brand": "if.kb",
      "kind": "module",
      "description": "Build-time developer knowledge base (KB) artifacts generated via `if.knowledge` (static Markdown/HTML; no runtime fetches). Preview: a bus/api KB snapshot is published; no deployed KB service on this host.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/kb",
      "slug": "if-kb",
      "bundle_slug": "if-kb-demo-bundle",
      "status": "preview"
    },
    {
      "product_id": "if.typeset",
      "brand": "iftypeset",
      "kind": "product",
      "description": "Deterministic document CI (lint → render HTML/PDF → QA) for review-proof packs.",
      "path": "/if/typeset",
      "slug": "if-typeset",
      "bundle_slug": "if-typeset-demo-bundle",
      "repo_dir": "ai-workspace/iftypeset",
      "status": "preview"
    },
    {
      "product_id": "if.gov",
      "brand": "IF.GOV",
      "kind": "product",
      "description": "Governance packs (triage/decision/external challenge) bound to receipts; not compliance guarantees.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/gov",
      "slug": "if-gov",
      "bundle_slug": "if-gov-demo-bundle",
      "status": "preview"
    },
    {
      "product_id": "if.gov.triage",
      "brand": "IF.GOV triage",
      "kind": "sku",
      "description": "Deliverable tier: triage memo + receipt-backed decision framing (not a compliance guarantee).",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/gov/triage",
      "slug": "if-gov-triage",
      "bundle_slug": "if-gov-triage-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.gov.council",
      "brand": "IF.GOV council",
      "kind": "sku",
      "description": "Deliverable tier: council-style decision pack with risks/controls/eval plan, bound to receipts.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/gov/council",
      "slug": "if-gov-council",
      "bundle_slug": "if-gov-council-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.gov.council.extended",
      "brand": "IF.GOV council extended",
      "kind": "sku",
      "description": "Deliverable tier: extended council pack + external challenge add-on (receipt-backed).",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/gov/council/extended",
      "slug": "if-gov-council-extended",
      "bundle_slug": "if-gov-council-extended-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.security",
      "brand": "if.security",
      "kind": "module",
      "description": "Cross-cutting security posture for InfraFabric modules (signals + evidence-typed actuation + containment mapping). Roadmap only; no deployed security runtime on this host.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/security",
      "slug": "if-security",
      "bundle_slug": "if-security-demo-bundle",
      "status": "roadmap"
    },
    {
      "product_id": "if.security.secrets.detect",
      "brand": "if.yologuard",
      "kind": "module",
      "description": "Receipt-backed secrets detection (audit mode, redacted outputs). Preview demo exists; not CI-integrated or 'live'.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/security/secrets/detect",
      "slug": "if-security-secrets-detect",
      "bundle_slug": "if-security-secrets-detect-demo-bundle",
      "repo_dir": "src/armour/secrets",
      "vendored_engine_dir": "armour/yologuard",
      "status": "preview"
    },
    {
      "product_id": "if.emotion",
      "brand": "IF.emotion",
      "kind": "product",
      "description": "Wellbeing-aware interaction layer (non-clinical) and governance-seat outputs with explicit safety boundaries; not diagnosis/therapy; not compliance guarantees.",
      "uses_receipts_from": [
        "if.trace"
      ],
      "path": "/if/emotion",
      "slug": "if-emotion",
      "bundle_slug": "if-emotion-demo-bundle",
      "status": "preview"
    }
  ]
}