@vectros-ai/blueprints 0.5.0 → 0.6.3

package/dist/index.js

@@ -199,11 +199,36 @@ var BlueprintServicePrincipalSchema = import_zod.z.object({
   externalId: import_zod.z.string().min(1),
   displayName: import_zod.z.string().min(1)
 }).strict();
-var BlueprintSeedRecordSchema = import_zod.z.object({
+var SeedCommonShape = {
+  /** The schema typeName this seed instantiates (should match a declared schema). */
   typeName: import_zod.z.string().min(1),
-  externalId: import_zod.z.string().min(1),
+  /**
+   * Stable, caller-supplied id — the loader's idempotency key AND the value other
+   * seeds resolve a `reference` against (across surfaces: a record seed may
+   * reference a document seed by its externalId, and vice versa).
+   */
+  externalId: import_zod.z.string().min(1)
+};
+var RecordSeedSchema = import_zod.z.object({
+  surface: import_zod.z.literal("record"),
+  ...SeedCommonShape,
+  /** The record payload, validated against the bound schema. */
   fields: import_zod.z.record(import_zod.z.unknown())
 }).strict();
+var DocumentSeedSchema = import_zod.z.object({
+  surface: import_zod.z.literal("document"),
+  ...SeedCommonShape,
+  /** Human-readable document title — REQUIRED by the text-ingest path. */
+  title: import_zod.z.string().min(1),
+  /** Raw text content to ingest + index — REQUIRED and non-empty (the platform rejects a blank ingest). */
+  text: import_zod.z.string().min(1),
+  /** Optional structured payload bound to the schema (the document's `fields`). */
+  fields: import_zod.z.record(import_zod.z.unknown()).optional()
+}).strict();
+var BlueprintSeedRecordSchema = import_zod.z.discriminatedUnion("surface", [
+  RecordSeedSchema,
+  DocumentSeedSchema
+]);
 var SELF_TOKEN_RE = /\$\{\{\s*self\.[A-Za-z_]\w*\s*\}\}/;
 function lintSelfTokenPlacement(value, ctx) {
   const walk = (node, path, inRoleDataScope) => {
@@ -259,6 +284,23 @@ function lintIdentityRefsDeclared(value, ctx) {
   };
   walk(value, []);
 }
+function lintSeedSurfaces(value, ctx) {
+  const bp = value;
+  if (!Array.isArray(bp.seed)) return;
+  const byType = new Map((bp.schemas ?? []).map((s) => [s.typeName, s]));
+  bp.seed.forEach((seed, i) => {
+    const schema = byType.get(seed.typeName);
+    if (!schema) return;
+    const allowed = schema.allowedSurfaces ?? ["record"];
+    if (!allowed.includes(seed.surface ?? "record")) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        path: ["seed", i, "surface"],
+        message: `seed '${seed.externalId}' uses surface '${seed.surface ?? "record"}', but schema '${seed.typeName}' allows only [${allowed.join(", ")}]`
+      });
+    }
+  });
+}
 var BlueprintSchema = import_zod.z.object({
   /** Stable blueprint id (the `--blueprint <name>` selector + idempotency key). */
   name: import_zod.z.string().min(1),
@@ -281,6 +323,7 @@ var BlueprintSchema = import_zod.z.object({
 }).strict().superRefine((bp, ctx) => {
   lintSelfTokenPlacement(bp, ctx);
   lintIdentityRefsDeclared(bp, ctx);
+  lintSeedSurfaces(bp, ctx);
 });
 function formatIssuePath(path) {
   let out = "";
@@ -759,6 +802,7 @@ var taskManagement = {
   },
   seed: [
     {
+      surface: "record",
       typeName: "task",
       externalId: "seed-welcome",
       fields: {
@@ -988,6 +1032,7 @@ var codingAgentMemory = {
       // Seeded FIRST so the convention below resolves its reference to it — the
       // loader creates seeds in array order, and a reference target must exist when
       // the referencing record is written.
+      surface: "record",
       typeName: "decision",
       externalId: "seed-use-vectros-for-memory",
       fields: {
@@ -1003,6 +1048,7 @@ var codingAgentMemory = {
       // Demonstrates a live typed link at bootstrap: this convention references the
       // decision above by its externalId, so "open the decision behind this rule"
       // works the moment the blueprint is applied.
+      surface: "record",
       typeName: "convention",
       externalId: "seed-record-the-why",
       fields: {
@@ -1018,6 +1064,703 @@ var codingAgentMemory = {
 };
 var coding_agent_memory_default = codingAgentMemory;
 
+// src/blueprints/agentic-sdlc.ts
+var DATA_PLANE_ACTIONS = [
+  "records:r",
+  "records:c",
+  "records:u",
+  "search:r",
+  "schemas:r",
+  "inference:r",
+  "documents:r",
+  "documents:c",
+  "folders:r",
+  "folders:c"
+];
+var agenticSdlc = {
+  name: "agentic-sdlc",
+  version: "1.0.0",
+  description: "A whole-SDLC system of record for an AI development team \u2014 decisions, designs, references, runbooks, post-mortems (as documents) plus controls, conventions, gotchas, and a glossary (as records), cross-linked and recalled by meaning.",
+  contextId: "agentic-sdlc",
+  contextName: "Agentic SDLC Knowledge Base",
+  schemas: [
+    // ============================ DOCUMENTS ============================
+    // Content-dominant: the markdown body is the artifact; fields are metadata.
+    // Each binds the `document` surface and is ingested via `document_ingest`.
+    {
+      // An architecture/product DECISION (an ADR). The body is the prose —
+      // Context / Decision / Consequences — and is what `rag_ask` answers over;
+      // the fields below are filter/sort metadata + the supersede chain. The
+      // anchor of the graph: most other types link back to a decision.
+      typeName: "decision",
+      displayName: "Decision (ADR)",
+      indexMode: "HYBRID",
+      allowedSurfaces: ["document"],
+      // A document carries an INTRINSIC title (the ingest title) + body; the schema
+      // declares only the metadata BEYOND those. (No typed `title` field — that
+      // would duplicate the document's own title.)
+      fields: [
+        {
+          fieldId: "summary",
+          fieldType: "string",
+          searchable: true,
+          description: "A one-paragraph abstract of the decision. The full reasoning is the document body.",
+          renderHints: { label: "Summary", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["proposed", "accepted", "superseded", "deprecated"],
+          renderHints: { label: "Status", widget: "select", order: 3 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          description: 'Subsystem the decision applies to (e.g. "search", "auth", "billing").',
+          renderHints: { label: "Area", widget: "text", order: 4 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          description: 'Freeform labels (e.g. "security", "schema"). Search-side filter.',
+          renderHints: { label: "Tags", order: 5 }
+        },
+        {
+          // Self-reference (document → document): the decision this one supersedes.
+          fieldId: "supersedes",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The decision this one supersedes (by externalId).",
+          renderHints: { label: "Supersedes", order: 6 }
+        },
+        {
+          fieldId: "date",
+          fieldType: "date",
+          description: "ISO-8601 decision date. Range-queryable / sortable.",
+          renderHints: { label: "Date", widget: "date", order: 7 }
+        }
+      ],
+      lookupFields: ["status", "area", "supersedes", { fieldName: "date", rangeEnabled: true }]
+    },
+    {
+      // A DESIGN doc or spec — the exploration that drives a decision. Distinct
+      // from `decision` (a different browse genre + it links to the decision it
+      // informs). Body = the design narrative.
+      typeName: "design",
+      displayName: "Design",
+      indexMode: "HYBRID",
+      allowedSurfaces: ["document"],
+      // Intrinsic title + body; schema = metadata beyond those (no typed `title`).
+      fields: [
+        {
+          fieldId: "summary",
+          fieldType: "string",
+          searchable: true,
+          description: "A one-paragraph abstract. The full design is the document body.",
+          renderHints: { label: "Summary", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["draft", "active", "implemented", "superseded"],
+          renderHints: { label: "Status", widget: "select", order: 3 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 4 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 5 }
+        },
+        {
+          // Cross-document edge: the decision this design informs/produces.
+          fieldId: "relatedDecision",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The decision this design informs (by externalId).",
+          renderHints: { label: "Related decision", order: 6 }
+        },
+        {
+          // Self-reference: a design supersedes an earlier design/spec.
+          fieldId: "supersedes",
+          fieldType: "reference",
+          targetTypeName: "design",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The design this one supersedes (by externalId).",
+          renderHints: { label: "Supersedes", order: 7 }
+        },
+        {
+          fieldId: "updatedOn",
+          fieldType: "date",
+          description: "ISO-8601 \u2014 when last revised. Range-queryable.",
+          renderHints: { label: "Updated on", widget: "date", order: 8 }
+        }
+      ],
+      lookupFields: ["status", "area", "relatedDecision", "supersedes", { fieldName: "updatedOn", rangeEnabled: true }]
+    },
+    {
+      // A REFERENCE doc — maintained "how it works / how to": guides, onboarding,
+      // API docs, process docs. Body = the prose. Distinct shape: a `category`
+      // (DRY sub-labels — onboarding/api/process are same shape) and `lastReviewed`
+      // (freshness is the whole game for reference material).
+      typeName: "reference",
+      displayName: "Reference",
+      indexMode: "HYBRID",
+      allowedSurfaces: ["document"],
+      // Intrinsic title + body; schema = metadata beyond those (no typed `title`).
+      fields: [
+        {
+          fieldId: "summary",
+          fieldType: "string",
+          searchable: true,
+          description: "A one-paragraph abstract. The full reference is the document body.",
+          renderHints: { label: "Summary", widget: "textarea", order: 2 }
+        },
+        {
+          // The sub-kind, as a filterable field (not a separate schema — these are
+          // the same shape, differing only by label, so a field is the DRY choice).
+          fieldId: "category",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["guide", "onboarding", "api", "process", "other"],
+          renderHints: { label: "Category", widget: "select", order: 3 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 4 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 5 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["active", "superseded"],
+          renderHints: { label: "Status", widget: "select", order: 6 }
+        },
+        {
+          // Optional cross-document edge: the decision behind this reference.
+          fieldId: "relatedDecision",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The decision behind this reference, if any (by externalId).",
+          renderHints: { label: "Related decision", order: 7 }
+        },
+        {
+          // Freshness — "references not reviewed since X". The reference-doc signal.
+          fieldId: "lastReviewed",
+          fieldType: "date",
+          description: "ISO-8601 \u2014 when this reference was last verified current. Range-queryable.",
+          renderHints: { label: "Last reviewed", widget: "date", order: 8 }
+        }
+      ],
+      lookupFields: ["category", "area", "status", "relatedDecision", { fieldName: "lastReviewed", rangeEnabled: true }]
+    },
+    {
+      // A RUNBOOK — a step-by-step operational procedure (deploy, release, recover).
+      // Body = the procedure. Distinct browse genre, and often BORN FROM a
+      // post-mortem (its resolution, codified) — a cross-document edge.
+      typeName: "runbook",
+      displayName: "Runbook",
+      indexMode: "HYBRID",
+      allowedSurfaces: ["document"],
+      // Intrinsic title + body; schema = metadata beyond those (no typed `title`).
+      fields: [
+        {
+          fieldId: "summary",
+          fieldType: "string",
+          searchable: true,
+          description: "When to use this runbook \u2014 the trigger. The steps are the document body.",
+          renderHints: { label: "Summary", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 3 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 4 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["active", "retired"],
+          renderHints: { label: "Status", widget: "select", order: 5 }
+        },
+        {
+          // Cross-document edge: the post-mortem whose resolution this runbook codifies.
+          fieldId: "bornFrom",
+          fieldType: "reference",
+          targetTypeName: "postmortem",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The post-mortem this runbook was codified from (by externalId).",
+          renderHints: { label: "Born from (post-mortem)", order: 6 }
+        },
+        {
+          fieldId: "relatedDecision",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "A decision this runbook implements, if any (by externalId).",
+          renderHints: { label: "Related decision", order: 7 }
+        },
+        {
+          fieldId: "updatedOn",
+          fieldType: "date",
+          description: "ISO-8601 \u2014 when last revised. Range-queryable.",
+          renderHints: { label: "Updated on", widget: "date", order: 8 }
+        }
+      ],
+      lookupFields: ["area", "status", "bornFrom", "relatedDecision", { fieldName: "updatedOn", rangeEnabled: true }]
+    },
+    {
+      // A POST-MORTEM — what broke and the durable lesson. Body = the writeup
+      // (impact / root cause / resolution / lesson). Distinct shape: `severity` +
+      // `occurredOn` (the incident timeline). "Have we hit this before?" lives here.
+      typeName: "postmortem",
+      displayName: "Post-mortem",
+      indexMode: "HYBRID",
+      allowedSurfaces: ["document"],
+      // Intrinsic title + body; schema = metadata beyond those (no typed `title`).
+      fields: [
+        {
+          fieldId: "summary",
+          fieldType: "string",
+          searchable: true,
+          description: "What happened, in brief. The full analysis (impact/root cause/resolution/lesson) is the body.",
+          renderHints: { label: "Summary", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "severity",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["low", "medium", "high", "critical"],
+          renderHints: { label: "Severity", widget: "select", order: 3 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["open", "mitigated", "resolved"],
+          renderHints: { label: "Status", widget: "select", order: 4 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 5 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 6 }
+        },
+        {
+          fieldId: "relatedDecision",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "A decision implicated in or addressed by this incident (by externalId).",
+          renderHints: { label: "Related decision", order: 7 }
+        },
+        {
+          fieldId: "occurredOn",
+          fieldType: "date",
+          description: 'ISO-8601 \u2014 when it happened. Range-queryable \u2014 "incidents this month".',
+          renderHints: { label: "Occurred on", widget: "date", order: 8 }
+        }
+      ],
+      lookupFields: ["severity", "status", "area", "relatedDecision", { fieldName: "occurredOn", rangeEnabled: true }]
+    },
+    // ============================= RECORDS =============================
+    // Structure-dominant: the typed fields are the artifact. Short, exact-queryable.
+    {
+      // A governance CONTROL — a policy/standard/control the codebase must satisfy,
+      // WITH its evidence. The compliance instrument: it records what enforces it
+      // (`evidence`), the runbook that VERIFIES it (cross-surface → document), and
+      // the decision that mandates it. "Which critical controls are active, and how
+      // is each proven?"
+      typeName: "control",
+      displayName: "Control",
+      indexMode: "HYBRID",
+      fields: [
+        {
+          fieldId: "title",
+          fieldType: "string",
+          required: true,
+          searchable: true,
+          validation: { minLength: 1, maxLength: 200 },
+          renderHints: { label: "Title", widget: "text", order: 1, displayField: true }
+        },
+        {
+          fieldId: "statement",
+          fieldType: "string",
+          searchable: true,
+          description: "The requirement \u2014 what must always hold.",
+          renderHints: { label: "Statement", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "rationale",
+          fieldType: "string",
+          searchable: true,
+          description: "Why the control exists \u2014 the risk it prevents.",
+          renderHints: { label: "Rationale", widget: "textarea", order: 3 }
+        },
+        {
+          // The policy → implementation spectrum in one filterable field.
+          fieldId: "kind",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["policy", "standard", "control"],
+          renderHints: { label: "Kind", widget: "select", order: 4 }
+        },
+        {
+          // Ordinal, but EQUALITY (range/prefix order is lexical, so low<critical
+          // would sort alphabetically). Enumerate "all critical controls" by equality.
+          fieldId: "criticality",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["low", "medium", "high", "critical"],
+          renderHints: { label: "Criticality", widget: "select", order: 5 }
+        },
+        {
+          fieldId: "evidence",
+          fieldType: "string",
+          searchable: true,
+          description: "What enforces or proves the control inline (e.g. an architecture test or gate).",
+          renderHints: { label: "Evidence", widget: "textarea", order: 6 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["draft", "active", "retired"],
+          renderHints: { label: "Status", widget: "select", order: 7 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 8 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 9 }
+        },
+        {
+          // Cross-surface edge (record → document): the runbook that proves the control.
+          fieldId: "verifiedBy",
+          fieldType: "reference",
+          targetTypeName: "runbook",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The runbook that verifies this control (by externalId).",
+          renderHints: { label: "Verified by (runbook)", order: 10 }
+        },
+        {
+          // Cross-surface edge (record → document): the decision that mandates it.
+          fieldId: "relatedDecision",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The decision that mandates this control (by externalId).",
+          renderHints: { label: "Related decision", order: 11 }
+        },
+        {
+          fieldId: "reviewedOn",
+          fieldType: "date",
+          description: "ISO-8601 last-reviewed date. Range-queryable.",
+          renderHints: { label: "Reviewed on", widget: "date", order: 12 }
+        }
+      ],
+      lookupFields: [
+        "kind",
+        "criticality",
+        "status",
+        "area",
+        "verifiedBy",
+        "relatedDecision",
+        { fieldName: "reviewedOn", rangeEnabled: true }
+      ]
+    },
+    {
+      // A CONVENTION — a must-follow operating rule the team teaches its agents. The
+      // durable, shareable operating-memory. Distinct fields capture how we actually
+      // write these: the `rule` (imperative), the `why` (rationale), and `howToApply`
+      // (the concrete application) are SEPARATE fields, not one blob — so an agent can
+      // recall the rule, the reasoning, and the how independently.
+      typeName: "convention",
+      displayName: "Convention",
+      indexMode: "HYBRID",
+      fields: [
+        {
+          fieldId: "title",
+          fieldType: "string",
+          required: true,
+          searchable: true,
+          validation: { minLength: 1, maxLength: 200 },
+          renderHints: { label: "Title", widget: "text", order: 1, displayField: true }
+        },
+        {
+          fieldId: "rule",
+          fieldType: "string",
+          searchable: true,
+          description: "The convention itself, stated as an imperative.",
+          renderHints: { label: "Rule", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "why",
+          fieldType: "string",
+          searchable: true,
+          description: "Why it matters \u2014 the trade-off / the antipattern it prevents.",
+          renderHints: { label: "Why", widget: "textarea", order: 3 }
+        },
+        {
+          fieldId: "howToApply",
+          fieldType: "string",
+          searchable: true,
+          description: "How to comply in practice \u2014 the concrete application steps.",
+          renderHints: { label: "How to apply", widget: "textarea", order: 4 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 5 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["active", "retired"],
+          renderHints: { label: "Status", widget: "select", order: 6 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 7 }
+        },
+        {
+          // Cross-surface edge (record → document): the decision that established it.
+          fieldId: "establishedBy",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "The decision that established this convention (by externalId).",
+          renderHints: { label: "Established by (decision)", order: 8 }
+        },
+        {
+          fieldId: "updatedOn",
+          fieldType: "date",
+          description: "ISO-8601 \u2014 when last revised. Range-queryable.",
+          renderHints: { label: "Updated on", widget: "date", order: 9 }
+        }
+      ],
+      lookupFields: ["area", "status", "establishedBy", { fieldName: "updatedOn", rangeEnabled: true }]
+    },
+    {
+      // A GOTCHA / sharp edge: a symptom, its cause, and the fix. A tight typed
+      // triple — found by meaning (semantic search on the symptom) + area/status.
+      // The most standalone type; no typed edge.
+      typeName: "gotcha",
+      displayName: "Gotcha",
+      indexMode: "HYBRID",
+      fields: [
+        {
+          fieldId: "symptom",
+          fieldType: "string",
+          required: true,
+          searchable: true,
+          validation: { minLength: 1, maxLength: 500 },
+          renderHints: { label: "Symptom", widget: "textarea", order: 1, displayField: true }
+        },
+        {
+          fieldId: "cause",
+          fieldType: "string",
+          searchable: true,
+          renderHints: { label: "Cause", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "fix",
+          fieldType: "string",
+          searchable: true,
+          renderHints: { label: "Fix", widget: "textarea", order: 3 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 4 }
+        },
+        {
+          fieldId: "status",
+          fieldType: "enum",
+          filterable: true,
+          enumValues: ["active", "resolved"],
+          renderHints: { label: "Status", widget: "select", order: 5 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 6 }
+        },
+        {
+          fieldId: "discoveredOn",
+          fieldType: "date",
+          description: "ISO-8601 \u2014 when first hit. Range-queryable.",
+          renderHints: { label: "Discovered on", widget: "date", order: 7 }
+        }
+      ],
+      lookupFields: ["area", "status", { fieldName: "discoveredOn", rangeEnabled: true }]
+    },
+    {
+      // A glossary TERM — a definition keyed by the term itself. Structure-dominant:
+      // `term` is a UNIQUE exact-lookup key (the showcase of a uniqueness constraint),
+      // `definition` is the RAG body, `aliases` catch alternate names. Links to the
+      // decision that defines/establishes the concept where there is one.
+      typeName: "term",
+      displayName: "Glossary term",
+      indexMode: "HYBRID",
+      fields: [
+        {
+          fieldId: "term",
+          fieldType: "string",
+          required: true,
+          searchable: true,
+          validation: { minLength: 1, maxLength: 200 },
+          renderHints: { label: "Term", widget: "text", order: 1, displayField: true }
+        },
+        {
+          fieldId: "definition",
+          fieldType: "string",
+          searchable: true,
+          description: "What the term means \u2014 the RAG-able body.",
+          renderHints: { label: "Definition", widget: "textarea", order: 2 }
+        },
+        {
+          fieldId: "aliases",
+          fieldType: "array",
+          filterable: true,
+          description: "Alternate names / abbreviations for the same concept.",
+          renderHints: { label: "Aliases", order: 3 }
+        },
+        {
+          fieldId: "area",
+          fieldType: "string",
+          filterable: true,
+          renderHints: { label: "Area", widget: "text", order: 4 }
+        },
+        {
+          fieldId: "tags",
+          fieldType: "array",
+          filterable: true,
+          renderHints: { label: "Tags", order: 5 }
+        },
+        {
+          fieldId: "relatedDecision",
+          fieldType: "reference",
+          targetTypeName: "decision",
+          targetSurface: "document",
+          targetField: "externalId",
+          cardinality: "one",
+          description: "A decision that defines or establishes this term (by externalId).",
+          renderHints: { label: "Related decision", order: 6 }
+        },
+        {
+          fieldId: "updatedOn",
+          fieldType: "date",
+          description: "ISO-8601 \u2014 when last revised. Range-queryable.",
+          renderHints: { label: "Updated on", widget: "date", order: 7 }
+        }
+      ],
+      // `term` is a UNIQUE equality lookup — exact "define X" + a one-per-term
+      // guarantee. `area`/`relatedDecision` enumerate; `updatedOn` is the range row.
+      lookupFields: [
+        { fieldName: "term", unique: true },
+        "area",
+        "relatedDecision",
+        { fieldName: "updatedOn", rangeEnabled: true }
+      ]
+    }
+  ],
+  // Least-privilege, data-plane only. The scope of the `ssk_*` key the bootstrap
+  // mints for THIS blueprint's service principal (the MCP/API runtime). See
+  // DATA_PLANE_ACTIONS above for the action set + rationale.
+  accessProfile: {
+    allowedActions: DATA_PLANE_ACTIONS
+  },
+  // A reusable `editor` role for the HUMAN owner — DISTINCT from `accessProfile`
+  // (which scopes only the service-principal key). `bootstrap` provisions this
+  // role in the context but binds it to no one; the owner joins themselves so the
+  // data-plane app (app.vectros.ai) shows their KB — its switcher lists only
+  // contexts the signed-in user holds an active access profile in, and bootstrap
+  // grants the human none by default. Bind it after bootstrap with:
+  //   vectros access grant --principal usr_<your-user-id> --context agentic-sdlc --role editor
+  // (or the admin app's Access > Contexts > agentic-sdlc > Profiles > Create).
+  // Editor PARITY with the service key (same DATA_PLANE_ACTIONS) so a human
+  // curator can browse AND write/correct the KB; still no :d and no control-plane
+  // action, so the scope gate accepts it exactly like the accessProfile.
+  roles: {
+    editor: [{ allowedActions: DATA_PLANE_ACTIONS }]
+  },
+  servicePrincipal: {
+    externalId: "agentic-sdlc",
+    displayName: "Agentic SDLC Knowledge Base"
+  }
+  // No bundled seed in this version: the content artifacts live on the document
+  // surface and the cross-surface graph is populated by the ingest agent
+  // (document_ingest / record_create), not the bootstrap seed step. Production
+  // contexts provision with `vectros bootstrap --no-seed` regardless.
+};
+var agentic_sdlc_default = agenticSdlc;
+
 // src/blueprints/second-brain.ts
 var secondBrain = {
   name: "second-brain",
@@ -1114,6 +1857,7 @@ var secondBrain = {
   },
   seed: [
     {
+      surface: "record",
       typeName: "note",
       externalId: "seed-welcome",
       fields: {
@@ -1247,6 +1991,7 @@ var clinicalIntake = {
   },
   seed: [
     {
+      surface: "record",
       typeName: "intake",
       externalId: "seed-synthetic-intake",
       fields: {
@@ -1270,6 +2015,7 @@ var clinical_intake_default = clinicalIntake;
 var BUNDLED_BLUEPRINTS = [
   task_management_default,
   coding_agent_memory_default,
+  agentic_sdlc_default,
   second_brain_default,
   clinical_intake_default
 ];