arkaik 0.1.2 → 0.3.0

package/dist/io.js

@@ -513,7 +513,7 @@ __export(core_exports2, {
   parse: () => parse,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
-  process: () => process,
+  process: () => process2,
   regexes: () => regexes_exports,
   registry: () => registry,
   safeDecode: () => safeDecode,
@@ -11438,7 +11438,7 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -11475,7 +11475,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -11763,14 +11763,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -12016,7 +12016,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json2.maxItems = maximum;
   json2.type = "array";
-  json2.items = process(def.element, ctx, {
+  json2.items = process2(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -12028,7 +12028,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process(shape[key], ctx, {
+    json2.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -12051,7 +12051,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json2.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process(def.catchall, ctx, {
+    json2.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12060,7 +12060,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -12072,11 +12072,11 @@ var unionProcessor = (schema, ctx, json2, params) => {
 };
 var intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -12093,11 +12093,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -12137,7 +12137,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -12147,12 +12147,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process(def.keyType, ctx, {
+      json2.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process(def.valueType, ctx, {
+    json2.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12167,7 +12167,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -12178,20 +12178,20 @@ var nullableProcessor = (schema, ctx, json2, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -12199,7 +12199,7 @@ var prefaultProcessor = (schema, ctx, json2, params) => {
 };
 var catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -12214,32 +12214,32 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -12291,7 +12291,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -12314,7 +12314,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -12372,7 +12372,7 @@ var JSONSchemaGenerator = class {
    * This must be called before emit().
    */
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
@@ -14929,6 +14929,7 @@ function crossCheckJournal(bundle) {
   });
   const everNodes = new Set(snapshotNodeStatus.keys());
   const everEdges = new Set(snapshotEdgeIds);
+  const baselined = /* @__PURE__ */ new Set();
   for (const { ev } of valid) {
     if (ev.type === "node.created") {
       const nid = str(ev.node_id);
@@ -14936,6 +14937,14 @@ function crossCheckJournal(bundle) {
     } else if (ev.type === "edge.added") {
       const eid = str(ev.edge_id);
       if (eid) everEdges.add(eid);
+    } else if (ev.type === "journal.baseline" && Array.isArray(ev.node_ids)) {
+      for (const raw of ev.node_ids) {
+        const nid = str(raw);
+        if (nid) {
+          baselined.add(nid);
+          everNodes.add(nid);
+        }
+      }
     }
   }
   const ordered = orderEvents(valid.map((v) => v.ev));
@@ -15001,7 +15010,7 @@ function crossCheckJournal(bundle) {
     }
   }
   for (const [nodeId, status] of snapshotNodeStatus) {
-    if (!created.has(nodeId)) {
+    if (!created.has(nodeId) && !baselined.has(nodeId)) {
       findings.push({
         path: "journal",
         rule: "journal-missing-node-created",
@@ -15033,6 +15042,26 @@ function crossCheckJournal(bundle) {
   }
   return findings;
 }
+function missingProvenanceNodeIds(snapshotNodeIds, events) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const ev of events) {
+    if (ev.type === "node.created") {
+      if (typeof ev.node_id === "string") covered.add(ev.node_id);
+    } else if (ev.type === "journal.baseline" && Array.isArray(ev.node_ids)) {
+      for (const id of ev.node_ids) {
+        if (typeof id === "string") covered.add(id);
+      }
+    }
+  }
+  const missing = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of snapshotNodeIds) {
+    if (covered.has(id) || seen.has(id)) continue;
+    seen.add(id);
+    missing.push(id);
+  }
+  return missing;
+}
 
 // ../schema/src/journal-events.ts
 var envelope = {
@@ -15099,7 +15128,12 @@ var DeliverableShippedEventSchema = external_exports.object({
   summary: external_exports.string().optional(),
   url: external_exports.string().optional(),
   node_ids: external_exports.array(external_exports.string()).optional(),
-  platform: PlatformSchema.optional()
+  platform: PlatformSchema.optional(),
+  lab_note: external_exports.object({
+    en: external_exports.object({ title: external_exports.string(), summary: external_exports.string() }).catchall(external_exports.unknown()),
+    fr: external_exports.object({ title: external_exports.string().optional(), summary: external_exports.string().optional() }).catchall(external_exports.unknown()).optional(),
+    suggested: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+  }).catchall(external_exports.unknown()).optional().meta({ description: "The Lab Note a merged PR carried (slice 3); en.title/en.summary required when present." })
 }).catchall(external_exports.unknown());
 var IdeaProposedEventSchema = external_exports.object({
   ...envelope,
@@ -15134,6 +15168,70 @@ var RefStatusChangedEventSchema = external_exports.object({
   to: external_exports.string(),
   synced_at: external_exports.string()
 }).catchall(external_exports.unknown());
+var JournalBaselineEventSchema = external_exports.object({ ...envelope, type: external_exports.literal("journal.baseline"), node_ids: external_exports.array(external_exports.string()) }).catchall(external_exports.unknown());
+var QualityAuditCompletedEventSchema = external_exports.object({
+  ...envelope,
+  type: external_exports.literal("quality.audit.completed"),
+  audit_id: external_exports.string(),
+  framework_version: external_exports.string(),
+  commit: external_exports.string().optional(),
+  scores: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.number())).optional(),
+  counts: external_exports.object({
+    critical: external_exports.number().optional(),
+    high: external_exports.number().optional(),
+    medium: external_exports.number().optional(),
+    low: external_exports.number().optional(),
+    info: external_exports.number().optional()
+  }).catchall(external_exports.unknown()).optional()
+}).catchall(external_exports.unknown());
+var QualityFindingOpenedEventSchema = external_exports.object({
+  ...envelope,
+  type: external_exports.literal("quality.finding.opened"),
+  finding_id: external_exports.string(),
+  criterion_id: external_exports.string(),
+  surface: external_exports.string(),
+  severity: external_exports.string(),
+  priority: external_exports.string(),
+  title: external_exports.string(),
+  node_ids: external_exports.array(external_exports.string()).optional(),
+  issue_url: external_exports.string().optional()
+}).catchall(external_exports.unknown());
+var QualityFindingResolvedEventSchema = external_exports.object({
+  ...envelope,
+  type: external_exports.literal("quality.finding.resolved"),
+  finding_id: external_exports.string(),
+  resolved_by: external_exports.string().optional(),
+  node_ids: external_exports.array(external_exports.string()).optional()
+}).catchall(external_exports.unknown());
+var QualitySignalTrippedEventSchema = external_exports.object({
+  ...envelope,
+  type: external_exports.literal("quality.signal.tripped"),
+  criterion_id: external_exports.string(),
+  surface: external_exports.string(),
+  signal: external_exports.string(),
+  detail: external_exports.string().optional()
+}).catchall(external_exports.unknown());
+var JOURNAL_EVENT_SCHEMAS = {
+  "node.created": NodeCreatedEventSchema,
+  "node.updated": NodeUpdatedEventSchema,
+  "node.status_changed": NodeStatusChangedEventSchema,
+  "decision.status_changed": DecisionStatusChangedEventSchema,
+  "node.deleted": NodeDeletedEventSchema,
+  "edge.added": EdgeAddedEventSchema,
+  "edge.removed": EdgeRemovedEventSchema,
+  "release.tagged": ReleaseTaggedEventSchema,
+  "deliverable.shipped": DeliverableShippedEventSchema,
+  "idea.proposed": IdeaProposedEventSchema,
+  "request.filed": RequestFiledEventSchema,
+  "ref.added": RefAddedEventSchema,
+  "ref.removed": RefRemovedEventSchema,
+  "ref.status_changed": RefStatusChangedEventSchema,
+  "journal.baseline": JournalBaselineEventSchema,
+  "quality.audit.completed": QualityAuditCompletedEventSchema,
+  "quality.finding.opened": QualityFindingOpenedEventSchema,
+  "quality.finding.resolved": QualityFindingResolvedEventSchema,
+  "quality.signal.tripped": QualitySignalTrippedEventSchema
+};
 var KnownJournalEventSchema = external_exports.union([
   NodeCreatedEventSchema,
   NodeUpdatedEventSchema,
@@ -15148,9 +15246,114 @@ var KnownJournalEventSchema = external_exports.union([
   RequestFiledEventSchema,
   RefAddedEventSchema,
   RefRemovedEventSchema,
-  RefStatusChangedEventSchema
+  RefStatusChangedEventSchema,
+  JournalBaselineEventSchema,
+  QualityAuditCompletedEventSchema,
+  QualityFindingOpenedEventSchema,
+  QualityFindingResolvedEventSchema,
+  QualitySignalTrippedEventSchema
 ]);
 
+// ../schema/src/quality-schemas.ts
+var GradeSchema = external_exports.enum(["A", "B", "C", "D", "E"]);
+var KritikScalesSchema = external_exports.object({
+  grades: external_exports.partialRecord(GradeSchema, external_exports.number()).optional(),
+  severity_buckets: external_exports.partialRecord(external_exports.enum(["critical", "high", "medium", "low", "info"]), external_exports.tuple([external_exports.number(), external_exports.number()])).optional(),
+  caps: external_exports.object({ critical_open: GradeSchema.optional(), high_open: GradeSchema.optional() }).catchall(external_exports.unknown()).optional()
+}).catchall(external_exports.unknown()).meta({
+  id: "KritikScales",
+  description: "Overridable maturity/severity/grade scales carried by a criteria pack. Absent entries fall back to the framework defaults (packages/kritik-library/SPEC.md \xA7 4)."
+});
+var KritikReferenceSchema = external_exports.object({ title: external_exports.string(), anchor: external_exports.string().optional(), url: external_exports.string().optional() }).catchall(external_exports.unknown()).meta({ id: "KritikReference", description: "A stable external anchor behind a criterion (OWASP control, GDPR article, WCAG SC\u2026)." });
+var KritikIssueTemplateSchema = external_exports.object({
+  title_template: external_exports.string().optional(),
+  labels: external_exports.array(external_exports.string()).optional(),
+  body_skeleton: external_exports.string().optional()
+}).catchall(external_exports.unknown()).meta({ id: "KritikIssueTemplate", description: "Per-criterion issue skeleton \u2014 what `arkaik kritik issue` prefills." });
+var KritikDomainSchema = external_exports.object({ code: external_exports.string(), name: external_exports.string(), description: external_exports.string().optional() }).catchall(external_exports.unknown()).meta({ id: "KritikDomain", description: "A top-level criteria category owning a roll-up row in the matrix." });
+var KritikCriterionSchema = external_exports.object({
+  id: external_exports.string().meta({ description: "Stable identifier, `<DOMAIN>-NN`. Never redefined \u2014 retired via superseded_by." }),
+  domain: external_exports.string(),
+  subcategory: external_exports.string().optional(),
+  name: external_exports.string().optional(),
+  question: external_exports.string().optional(),
+  definition: external_exports.string().optional(),
+  rationale: external_exports.string().optional(),
+  applies_to: external_exports.array(external_exports.string()).optional().meta({ description: "Surface ids where the criterion is meaningful; absence means N/A." }),
+  level_anchors: external_exports.record(external_exports.string(), external_exports.string()).optional().meta({ description: "Observable descriptions per maturity level, keyed l0\u2026l4." }),
+  default_impact: external_exports.number().optional(),
+  weight: external_exports.number().optional().meta({ description: "Weight in the domain roll-up (1\u20133; 3 = load-bearing). Absent means 1." }),
+  references: external_exports.array(KritikReferenceSchema).optional(),
+  checklist: external_exports.array(external_exports.string()).optional(),
+  signals: external_exports.array(external_exports.string()).optional().meta({ description: "Mechanically checkable monitoring hooks run between audits." }),
+  remediation: external_exports.string().optional(),
+  issue: KritikIssueTemplateSchema.optional(),
+  superseded_by: external_exports.string().optional()
+}).catchall(external_exports.unknown()).meta({ id: "KritikCriterion", description: "The atomic auditable unit (packages/kritik-library/SPEC.md \xA7 5)." });
+var KritikLibrarySchema = external_exports.object({
+  version: external_exports.string().meta({ description: "Semver of the pack; matrices are comparable only within a major." }),
+  domains: external_exports.array(KritikDomainSchema),
+  criteria: external_exports.array(KritikCriterionSchema),
+  scales: KritikScalesSchema.optional()
+}).catchall(external_exports.unknown()).meta({
+  id: "KritikLibrary",
+  description: "A versioned criteria pack. Embedded on export; repos may instead pin it as a sidecar file."
+});
+var SurfaceDefSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  platform: PlatformSchema.optional().meta({
+    description: "Optional bridge to PLATFORM_IDS where a surface is also a view-shipping platform. Surfaces are not platforms (RFC \xA7 2)."
+  }),
+  path: external_exports.string().optional()
+}).catchall(external_exports.unknown()).meta({ id: "SurfaceDef", description: "One independently assessable body of code \u2014 an audit target, chosen at install." });
+var QualityProfileSchema = external_exports.object({
+  surfaces: external_exports.array(SurfaceDefSchema),
+  domain_weights: external_exports.record(external_exports.string(), external_exports.number()).optional().meta({
+    description: "Per-domain weight in the surface roll-up, keyed by domain code. A missing weight is 1."
+  })
+}).catchall(external_exports.unknown()).meta({ id: "QualityProfile", description: "The project's parameterization of the pack (RFC \xA7 6)." });
+var QualityAssessmentSchema = external_exports.object({
+  criterion_id: external_exports.string(),
+  surface: external_exports.string(),
+  level: external_exports.union([external_exports.literal(0), external_exports.literal(1), external_exports.literal(2), external_exports.literal(3), external_exports.literal(4)]).meta({
+    description: "Maturity 0\u20134. N/A is the absence of the row, never a level."
+  }),
+  evidence: external_exports.string().meta({ description: "file:line / config citations. A score without evidence is an opinion, not an assessment." }),
+  audit_id: external_exports.string(),
+  commit: external_exports.string().optional(),
+  ts: external_exports.string()
+}).catchall(external_exports.unknown()).meta({ id: "QualityAssessment", description: "One (criterion \xD7 surface) score \u2014 latest wins; history lives in the journal." });
+var QualityFindingSchema = external_exports.object({
+  id: external_exports.string(),
+  criterion_id: external_exports.string(),
+  surface: external_exports.string(),
+  title: external_exports.string(),
+  detail: external_exports.string(),
+  evidence: external_exports.string(),
+  impact: external_exports.number().meta({ description: "Worst plausible consequence, 1\u20135." }),
+  likelihood: external_exports.number().meta({ description: "Probability it materializes, 1\u20135." }),
+  cost: external_exports.enum(["S", "M", "L", "XL"]),
+  status: external_exports.enum(["open", "resolved", "refuted", "accepted-risk"]),
+  remediation: external_exports.string().optional(),
+  node_ids: external_exports.array(external_exports.string()).optional().meta({ description: "Graph nodes this finding is about \u2014 the tie deliverable.shipped already uses." }),
+  issue_url: external_exports.string().optional(),
+  verification: external_exports.object({ verdict: external_exports.enum(["CONFIRMED", "REFUTED", "DOWNGRADED"]), note: external_exports.string().optional() }).catchall(external_exports.unknown()).optional().meta({ description: "Result of the adversarial refutation pass. Refuted findings are disclosed, not deleted." })
+}).catchall(external_exports.unknown()).meta({
+  id: "QualityFinding",
+  description: "One concrete defect. Severity and priority are deliberately absent \u2014 they are derived from impact \xD7 likelihood and cost (deriveQualityMatrix), so a finding can never carry a severity its own numbers disagree with."
+});
+var QualitySectionSchema = external_exports.object({
+  framework_version: external_exports.string(),
+  library: KritikLibrarySchema.optional(),
+  profile: QualityProfileSchema,
+  assessments: external_exports.array(QualityAssessmentSchema),
+  findings: external_exports.array(QualityFindingSchema)
+}).catchall(external_exports.unknown()).meta({
+  id: "QualitySection",
+  description: "The project's Kritik state (docs/rfcs/kritik.md \xA7 4.1) \u2014 profile, assessments, findings. Criteria are library content, not graph nodes; the matrix is a projection, never stored."
+});
+
 // ../schema/src/bundle.ts
 var PlatformStatusMapSchema = external_exports.partialRecord(
   PlatformSchema,
@@ -15292,7 +15495,8 @@ var ProjectMetadataSchema = external_exports.object({
   }),
   products: external_exports.array(ProductDefinitionSchema).optional().meta({
     description: "Product definitions (docs/spec/bundle-format.md \xA7 Products) \u2014 additive; unknown fields preserved."
-  })
+  }),
+  pollen: external_exports.object({ plant: external_exports.string().regex(/^[a-z0-9][a-z0-9-]*$/).optional() }).catchall(external_exports.unknown()).optional().meta({ description: "Federation settings \u2014 docs/spec/services.md \xA7 Pollen feed. `plant` enables the feed." })
 }).catchall(external_exports.unknown()).meta({ id: "ProjectMetadata", description: "Optional project-level UI settings." });
 var ProjectSchema = external_exports.object({
   id: external_exports.string().meta({ description: "Unique project identifier." }),
@@ -15320,6 +15524,9 @@ var ProjectBundleSchema = external_exports.object({
   edges: external_exports.array(EdgeSchema).meta({ description: "All edges (relationships) between nodes." }),
   journal: external_exports.array(JournalEventSchema).optional().meta({
     description: "Optional embedded journal events \u2014 the Level 2 interchange projection (docs/spec/journal.md). Canonical storage in repos is the JSONL sidecar; a bundle without a journal is Level 0/1, not an error."
+  }),
+  quality: QualitySectionSchema.optional().meta({
+    description: "Optional Kritik quality state (docs/rfcs/kritik.md \xA7 4.1) \u2014 the pinned pack version, the project's surface profile, its assessments and findings. Additive: a bundle without it is not an error, and the comparative matrix is derived from it (deriveQualityMatrix), never stored."
   })
 }).catchall(external_exports.unknown()).meta({
   id: "ProjectBundle",
@@ -15327,15 +15534,6 @@ var ProjectBundleSchema = external_exports.object({
   description: "The import/export format for an Arkaik product graph. Contains a project, its nodes (flows, views, data models, API endpoints), and edges (relationships between nodes)."
 });
 
-// ../schema/src/maps.ts
-var MAP_FLOW_PLATFORMS_MODES = ["rings", "bars"];
-var MAP_VIEW_PLATFORMS_MODES = ["chips", "rows"];
-var MAP_MINIMAP_COLOR_MODES = ["status", "species"];
-var BUILT_IN_MAP_IDS = ["journey", "system"];
-function isBuiltInMapId(id) {
-  return BUILT_IN_MAP_IDS.includes(id);
-}
-
 // ../schema/src/products.ts
 var PRODUCT_MEMBERSHIP_SPECIES = ["flow", "view", "acceptance"];
 function resolveProducts(project) {
@@ -15353,6 +15551,38 @@ function resolveProducts(project) {
   return products;
 }
 
+// ../schema/src/maps.ts
+var MAP_FLOW_PLATFORMS_MODES = ["rings", "bars"];
+var MAP_VIEW_PLATFORMS_MODES = ["chips", "rows"];
+var MAP_MINIMAP_COLOR_MODES = ["status", "species"];
+var BUILT_IN_MAP_IDS = ["journey", "system"];
+function isBuiltInMapId(id) {
+  return BUILT_IN_MAP_IDS.includes(id);
+}
+
+// ../schema/src/quality.ts
+var asArray = (value) => Array.isArray(value) ? value : [];
+var CROSS_SURFACE_ID = "cross-surface";
+function mergeKritikLibrary(pack, overlay) {
+  if (!overlay || typeof overlay !== "object") return pack;
+  const domains = [...asArray(pack.domains)];
+  for (const domain2 of asArray(overlay.domains)) {
+    if (typeof domain2?.code !== "string" || domain2.code === "") continue;
+    const at = domains.findIndex((existing) => existing?.code === domain2.code);
+    if (at >= 0) domains[at] = domain2;
+    else domains.push(domain2);
+  }
+  const criteria = [...asArray(pack.criteria)];
+  for (const criterion of asArray(overlay.criteria)) {
+    if (typeof criterion?.id !== "string" || criterion.id === "") continue;
+    const at = criteria.findIndex((existing) => existing?.id === criterion.id);
+    if (at >= 0) criteria[at] = criterion;
+    else criteria.push(criterion);
+  }
+  const scales = pack.scales || overlay.scales ? { ...pack.scales ?? {}, ...overlay.scales ?? {} } : void 0;
+  return { ...pack, domains, criteria, ...scales ? { scales } : {} };
+}
+
 // ../schema/src/validate.ts
 var VALID_STAGES = ["beta", "monitoring", "deprecated"];
 var VALID_VIEW_CARD_VARIANTS = ["compact", "large"];
@@ -15869,13 +16099,98 @@ function validateBundle(input) {
       composesSet.add(`${sourceId}->${targetId}`);
     }
   });
+  const PLAYLIST_ENTRY_TYPES = ["view", "flow", "condition", "junction"];
+  const checkPlaylistShape = (entries, flowId, path, depth = 0) => {
+    if (depth > 50) return;
+    if (!Array.isArray(entries)) {
+      error51(path, "playlist-entry-shape", `Flow ${flowId}: ${path} must be an array of playlist entries`);
+      return;
+    }
+    entries.forEach((raw, i) => {
+      const p = `${path}[${i}]`;
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        error51(p, "playlist-entry-shape", `Flow ${flowId}: ${p} must be a playlist entry object`);
+        return;
+      }
+      const entry = raw;
+      const type = entry.type;
+      if (typeof type !== "string" || !PLAYLIST_ENTRY_TYPES.includes(type)) {
+        error51(
+          `${p}.type`,
+          "playlist-entry-shape",
+          `Flow ${flowId}: ${p}.type must be one of ${PLAYLIST_ENTRY_TYPES.join(", ")} (got ${JSON.stringify(type)})`
+        );
+        return;
+      }
+      if (type === "view") {
+        if (typeof entry.view_id !== "string") {
+          error51(`${p}.view_id`, "playlist-entry-shape", `Flow ${flowId}: ${p} is a view entry with no view_id string`);
+        }
+      } else if (type === "flow") {
+        if (typeof entry.flow_id !== "string") {
+          error51(`${p}.flow_id`, "playlist-entry-shape", `Flow ${flowId}: ${p} is a flow entry with no flow_id string`);
+        }
+      } else if (type === "condition") {
+        if (typeof entry.label !== "string") {
+          error51(`${p}.label`, "playlist-entry-shape", `Flow ${flowId}: ${p} is a condition with no label string`);
+        }
+        for (const branch of ["if_true", "if_false"]) {
+          if (!Array.isArray(entry[branch])) {
+            error51(
+              `${p}.${branch}`,
+              "playlist-entry-shape",
+              `Flow ${flowId}: ${p}.${branch} must be an array of playlist entries (both branches are required, use [] for an empty one)`
+            );
+          } else {
+            checkPlaylistShape(entry[branch], flowId, `${p}.${branch}`, depth + 1);
+          }
+        }
+      } else {
+        if (typeof entry.label !== "string") {
+          error51(`${p}.label`, "playlist-entry-shape", `Flow ${flowId}: ${p} is a junction with no label string`);
+        }
+        if (!Array.isArray(entry.cases)) {
+          error51(`${p}.cases`, "playlist-entry-shape", `Flow ${flowId}: ${p}.cases must be an array of junction cases`);
+          return;
+        }
+        entry.cases.forEach((rawCase, j) => {
+          const cp = `${p}.cases[${j}]`;
+          if (typeof rawCase !== "object" || rawCase === null || Array.isArray(rawCase)) {
+            error51(cp, "playlist-entry-shape", `Flow ${flowId}: ${cp} must be a junction case object`);
+            return;
+          }
+          const branch = rawCase;
+          if (typeof branch.label !== "string") {
+            error51(`${cp}.label`, "playlist-entry-shape", `Flow ${flowId}: ${cp} has no label string`);
+          }
+          if (!Array.isArray(branch.entries)) {
+            error51(
+              `${cp}.entries`,
+              "playlist-entry-shape",
+              `Flow ${flowId}: ${cp}.entries must be an array of playlist entries \u2014 a junction case holds its own entries, not a bare view_id/flow_id`
+            );
+          } else {
+            checkPlaylistShape(branch.entries, flowId, `${cp}.entries`, depth + 1);
+          }
+        });
+      }
+    });
+  };
+  nodes.forEach((node, i) => {
+    const md = node.metadata;
+    if (node.species === "flow" && md?.playlist?.entries) {
+      checkPlaylistShape(md.playlist.entries, node.id, `nodes[${i}].metadata.playlist.entries`);
+    }
+  });
   const collectPlaylistRefs = (entries, flowId, path, depth = 0) => {
     if (depth > 50) {
       error51(path, "playlist-depth", `Flow ${flowId}: playlist nesting too deep (possible cycle)`);
       return [];
     }
     const refs = [];
+    if (!Array.isArray(entries)) return refs;
     for (const entry of entries) {
+      if (typeof entry !== "object" || entry === null) continue;
       if (entry.type === "view") {
         if (!nodeIds.has(entry.view_id)) {
           error51(path, "playlist-ref-exists", `Flow ${flowId}: playlist references non-existent view "${entry.view_id}"`);
@@ -15927,7 +16242,9 @@ function validateBundle(input) {
       const nodeId = node.id;
       const subFlows = [];
       const findSubFlows = (entries) => {
+        if (!Array.isArray(entries)) return;
         for (const e of entries) {
+          if (typeof e !== "object" || e === null) continue;
           if (e.type === "flow") subFlows.push(e.flow_id);
           if (e.type === "condition") {
             if (e.if_true) findSubFlows(e.if_true);
@@ -15962,6 +16279,151 @@ function validateBundle(input) {
   for (const id of flowGraph.keys()) {
     dfs(id);
   }
+  const quality = bundle.quality;
+  if (typeof quality === "object" && quality !== null && !Array.isArray(quality)) {
+    const section = quality;
+    const assessments = Array.isArray(section.assessments) ? section.assessments : [];
+    const qualityFindings = Array.isArray(section.findings) ? section.findings : [];
+    const profile = typeof section.profile === "object" && section.profile !== null ? section.profile : void 0;
+    const declaredSurfaces = /* @__PURE__ */ new Set();
+    if (Array.isArray(profile?.surfaces)) {
+      profile.surfaces.forEach((entry, index) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return;
+        const surface = entry;
+        const surfaceId = typeof surface.id === "string" ? surface.id : void 0;
+        if (surfaceId === void 0 || surfaceId.trim() === "") return;
+        if (declaredSurfaces.has(surfaceId)) {
+          warn(`quality.profile.surfaces[${index}].id`, "quality-duplicate-surface", `Duplicate surface id "${surfaceId}" \u2014 the first wins`);
+        }
+        declaredSurfaces.add(surfaceId);
+      });
+    }
+    if (declaredSurfaces.size === 0 && (assessments.length > 0 || qualityFindings.length > 0)) {
+      warn(
+        "quality.profile.surfaces",
+        "quality-no-surfaces",
+        "Quality data is stored but the profile declares no surfaces \u2014 the matrix falls back to the surfaces the assessments name"
+      );
+    }
+    const library = typeof section.library === "object" && section.library !== null ? section.library : void 0;
+    const knownCriteria = /* @__PURE__ */ new Set();
+    const retiredCriteria = /* @__PURE__ */ new Map();
+    if (Array.isArray(library?.criteria)) {
+      for (const entry of library.criteria) {
+        if (typeof entry !== "object" || entry === null) continue;
+        const criterion = entry;
+        if (typeof criterion.id !== "string") continue;
+        knownCriteria.add(criterion.id);
+        if (typeof criterion.superseded_by === "string" && criterion.superseded_by !== "") {
+          retiredCriteria.set(criterion.id, criterion.superseded_by);
+        }
+      }
+    } else if (assessments.length > 0 || qualityFindings.length > 0) {
+      warn(
+        "quality.library",
+        "quality-library-missing",
+        "No criteria pack is embedded \u2014 criterion ids cannot be resolved to domains or weights; the matrix uses a synthesized library"
+      );
+    }
+    if (typeof section.framework_version !== "string" || section.framework_version === "") {
+      warn("quality.framework_version", "quality-framework-version-missing", "Quality section has no framework_version \u2014 scores are not comparable across audits without one");
+    }
+    const checkRowRefs = (row, path, label) => {
+      const criterionId = typeof row.criterion_id === "string" ? row.criterion_id : void 0;
+      if (criterionId !== void 0 && knownCriteria.size > 0 && !knownCriteria.has(criterionId)) {
+        warn(`${path}.criterion_id`, "quality-unknown-criterion", `${label}: criterion "${criterionId}" is not in the pinned library`);
+      }
+      const supersededBy = criterionId !== void 0 ? retiredCriteria.get(criterionId) : void 0;
+      if (supersededBy !== void 0) {
+        warn(`${path}.criterion_id`, "quality-retired-criterion", `${label}: criterion "${criterionId}" is retired \u2014 superseded by "${supersededBy}"`);
+      }
+      const surface = typeof row.surface === "string" ? row.surface : void 0;
+      if (surface !== void 0 && surface !== CROSS_SURFACE_ID && declaredSurfaces.size > 0 && !declaredSurfaces.has(surface)) {
+        warn(`${path}.surface`, "quality-unknown-surface", `${label}: surface "${surface}" is not declared in the profile`);
+      }
+    };
+    const seenCells = /* @__PURE__ */ new Set();
+    assessments.forEach((entry, index) => {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return;
+      const assessment = entry;
+      const path = `quality.assessments[${index}]`;
+      const label = `Assessment ${index}`;
+      checkRowRefs(assessment, path, label);
+      const level = assessment.level;
+      if (typeof level !== "number" || !Number.isInteger(level) || level < 0 || level > 4) {
+        warn(`${path}.level`, "quality-level-range", `${label}: level must be an integer 0-4 (N/A is the absence of the row, not a level)`);
+      }
+      if (assessment.surface === CROSS_SURFACE_ID) {
+        warn(`${path}.surface`, "quality-cross-surface-assessment", `${label}: "${CROSS_SURFACE_ID}" is a findings-only lens \u2014 it carries no matrix column, so this score would render nowhere`);
+      }
+      if (typeof assessment.evidence !== "string" || assessment.evidence.trim() === "") {
+        warn(`${path}.evidence`, "quality-assessment-no-evidence", `${label}: scored with no evidence \u2014 a score without a citation is an opinion, not an assessment`);
+      }
+      const criterionId = typeof assessment.criterion_id === "string" ? assessment.criterion_id : void 0;
+      const surface = typeof assessment.surface === "string" ? assessment.surface : void 0;
+      if (criterionId !== void 0 && surface !== void 0) {
+        const cell = `${criterionId}\0${surface}`;
+        if (seenCells.has(cell)) {
+          warn(`${path}`, "quality-duplicate-assessment", `${label}: a second score for (${criterionId} x ${surface}) \u2014 the section stores latest-per-cell, so this cell is ambiguous`);
+        }
+        seenCells.add(cell);
+      }
+    });
+    const seenFindingIds = /* @__PURE__ */ new Set();
+    qualityFindings.forEach((entry, index) => {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return;
+      const finding = entry;
+      const path = `quality.findings[${index}]`;
+      const label = `Finding ${index}`;
+      checkRowRefs(finding, path, label);
+      const findingId = typeof finding.id === "string" ? finding.id : void 0;
+      if (findingId !== void 0) {
+        if (seenFindingIds.has(findingId)) {
+          warn(`${path}.id`, "quality-duplicate-finding-id", `Duplicate finding id "${findingId}"`);
+        }
+        seenFindingIds.add(findingId);
+      }
+      for (const field of ["impact", "likelihood"]) {
+        const value = finding[field];
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 5) {
+          warn(`${path}.${field}`, "quality-risk-range", `${label}: ${field} must be an integer 1-5 \u2014 severity is derived from impact x likelihood`);
+        }
+      }
+      for (const derived of ["severity", "priority"]) {
+        if (derived in finding) {
+          warn(`${path}.${derived}`, "quality-derived-field-stored", `${label}: ${derived} is derived from impact, likelihood and cost \u2014 storing it lets it drift from the numbers behind it`);
+        }
+      }
+      if (finding.status === "accepted-risk" && (typeof finding.detail !== "string" || finding.detail.trim() === "")) {
+        warn(`${path}.detail`, "quality-accepted-risk-no-note", `${label}: accepted-risk with no note \u2014 an accepted risk is a decision and reads like one`);
+      }
+    });
+    const openedInJournal = /* @__PURE__ */ new Set();
+    const journalEvents = Array.isArray(bundle.journal) ? bundle.journal : [];
+    journalEvents.forEach((entry) => {
+      if (typeof entry !== "object" || entry === null) return;
+      const event = entry;
+      if (event.type === "quality.finding.opened" && typeof event.finding_id === "string") openedInJournal.add(event.finding_id);
+    });
+    journalEvents.forEach((entry, index) => {
+      if (typeof entry !== "object" || entry === null) return;
+      const event = entry;
+      const type = typeof event.type === "string" ? event.type : "";
+      if (!type.startsWith("quality.")) return;
+      if (typeof event.actor !== "string" || event.actor.trim() === "") {
+        warn(`journal[${index}].actor`, "quality-event-no-actor", `Journal event ${index}: ${type} has no actor \u2014 human, agent and CI scores become indistinguishable`);
+      }
+      if (type === "quality.finding.resolved" && typeof event.finding_id === "string") {
+        if (!openedInJournal.has(event.finding_id) && !seenFindingIds.has(event.finding_id)) {
+          warn(
+            `journal[${index}].finding_id`,
+            "quality-resolved-never-opened",
+            `Journal event ${index}: resolves finding "${event.finding_id}", which no quality.finding.opened event or stored finding ever declared`
+          );
+        }
+      }
+    });
+  }
   for (const finding of crossCheckJournal(bundle)) findings.push(finding);
   return result();
 }
@@ -15969,6 +16431,58 @@ function validateBundle(input) {
 // ../schema/src/emit.ts
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(time3, len) {
+  let out = "";
+  let t = time3;
+  for (let i = len - 1; i >= 0; i -= 1) {
+    const mod = t % ENCODING_LEN;
+    out = ENCODING[mod] + out;
+    t = (t - mod) / ENCODING_LEN;
+  }
+  return out;
+}
+function randomSymbols(len) {
+  const bytes = new Uint8Array(len);
+  globalThis.crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b & 31);
+}
+function incrementSymbols(symbols) {
+  const out = symbols.slice();
+  for (let i = out.length - 1; i >= 0; i -= 1) {
+    if (out[i] < ENCODING_LEN - 1) {
+      out[i] += 1;
+      return out;
+    }
+    out[i] = 0;
+  }
+  return randomSymbols(RANDOM_LEN);
+}
+var lastTime = -1;
+var lastRandom = [];
+function ulid3(seedTime = Date.now()) {
+  if (seedTime > lastTime) {
+    lastTime = seedTime;
+    lastRandom = randomSymbols(RANDOM_LEN);
+  } else {
+    lastRandom = incrementSymbols(lastRandom);
+  }
+  return encodeTime(lastTime, TIME_LEN) + lastRandom.map((s) => ENCODING[s]).join("");
+}
+function makeEvent(type, payload = {}, options = {}) {
+  const ts = options.ts instanceof Date ? options.ts.toISOString() : options.ts ?? (/* @__PURE__ */ new Date()).toISOString();
+  const id = options.id ?? ulid3();
+  const event = {
+    id,
+    ts,
+    ...options.actor !== void 0 ? { actor: options.actor } : {},
+    type,
+    ...payload
+  };
+  const schema = JOURNAL_EVENT_SCHEMAS[type] ?? JournalEventSchema;
+  return schema.parse(event);
+}
 
 // src/lib/bundle-io.ts
 function readBundle(filePath) {
@@ -15998,7 +16512,7 @@ function nodesByIdOf(bundle) {
 }
 
 // src/lib/journal-io.ts
-import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 var JOURNAL_SIDECAR = "journal.jsonl";
 function journalPathFor(bundlePath) {
@@ -16007,10 +16521,22 @@ function journalPathFor(bundlePath) {
 function archivePathFor(journalPath, version2) {
   return join(dirname(journalPath), "journal", `archive-${version2}.jsonl`);
 }
+function archivePathsFor(journalPath) {
+  const dir = join(dirname(journalPath), "journal");
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir).filter((name) => name.startsWith("archive-") && name.endsWith(".jsonl")).sort().map((name) => join(dir, name));
+}
 function readJournalEvents(journalPath) {
   if (!existsSync2(journalPath)) return [];
   return parseJournalLines(readFileSync2(journalPath, "utf8")).events;
 }
+function readFullJournalEvents(journalPath) {
+  const events = readJournalEvents(journalPath);
+  for (const archivePath of archivePathsFor(journalPath)) {
+    events.push(...readJournalEvents(archivePath));
+  }
+  return events;
+}
 function loadJournalEvents(bundle, bundlePath) {
   if (Array.isArray(bundle.journal)) return bundle.journal;
   return readJournalEvents(journalPathFor(bundlePath));
@@ -16029,6 +16555,14 @@ function appendJournalEvent(journalPath, event) {
   const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
   appendFileSync(journalPath, prefix + line);
 }
+function ensureJournalBaseline(journalPath, bundle, actor) {
+  const snapshotNodeIds = (Array.isArray(bundle.nodes) ? bundle.nodes : []).map((node) => node?.id).filter((id) => typeof id === "string");
+  const missing = missingProvenanceNodeIds(snapshotNodeIds, readFullJournalEvents(journalPath));
+  if (missing.length === 0) return void 0;
+  const event = makeEvent("journal.baseline", { node_ids: missing }, { actor });
+  appendJournalEvent(journalPath, event);
+  return event;
+}
 function compactSlice(journalPath, slice, version2) {
   if (slice.length === 0) return;
   const sliceIds = new Set(slice.map((ev) => ev.id));
@@ -16047,10 +16581,72 @@ function compactSlice(journalPath, slice, version2) {
   writeFileSync(journalPath, surviving.map(toLine).join(""));
 }
 
+// src/lib/kritik-io.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { basename, dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../schema/src/cli/kritik-paths.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
+var QUALITY_DIR = "docs/quality";
+var OVERLAY_FILE = "criteria.custom.json";
+var PACK_FILE = "library.json";
+function readJson(path) {
+  const text = readFileSync3(path, "utf8");
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new Error(`${path}: not valid JSON \u2014 ${e.message}`);
+  }
+}
+var overlayPath = (root) => join2(root, QUALITY_DIR, OVERLAY_FILE);
+function loadOverlay(root) {
+  const path = overlayPath(root);
+  return existsSync3(path) ? readJson(path) : null;
+}
+
+// src/lib/kritik-io.ts
+var KRITIK_ACTOR = "arkaik-cli";
+var DEFAULT_BUNDLE_PATH = join3("docs", "arkaik", "bundle.json");
+var VENDORED_PACK = join3(QUALITY_DIR, PACK_FILE);
+var BUNDLED_PACK = join3(dirname3(fileURLToPath(import.meta.url)), "assets", "kritik", "library.json");
+function resolvePack(root) {
+  const vendored = join3(root, VENDORED_PACK);
+  if (existsSync4(vendored)) return { library: readJson(vendored), path: vendored, vendored: true };
+  if (!existsSync4(BUNDLED_PACK)) {
+    throw new Error(
+      `no criteria pack found. Looked in:
+  ${vendored}
+  ${BUNDLED_PACK}
+The second is shipped with this CLI, so its absence means a broken install \u2014 reinstall \`arkaik\`.`
+    );
+  }
+  return { library: readJson(BUNDLED_PACK), path: BUNDLED_PACK, vendored: false };
+}
+function loadKritikLibrary(root) {
+  const pack = resolvePack(root);
+  return { library: mergeKritikLibrary(pack.library, loadOverlay(root)), pack };
+}
+function resolveJournal(root, bundlePath) {
+  const resolved = bundlePath ?? join3(root, DEFAULT_BUNDLE_PATH);
+  return { bundlePath: resolved, journalPath: journalPathFor(resolved), present: existsSync4(resolved) };
+}
+function appendQualityEvents(root, inputs, options = {}) {
+  if (inputs.length === 0) return { events: [] };
+  const actor = options.actor ?? KRITIK_ACTOR;
+  const journal = resolveJournal(root, options.bundlePath);
+  if (!journal.present) return { events: [] };
+  const bundle = readBundle(journal.bundlePath);
+  const baseline = ensureJournalBaseline(journal.journalPath, bundle, actor);
+  const events = inputs.map((input) => makeEvent(input.type, input.payload, { actor }));
+  for (const event of events) appendJournalEvent(journal.journalPath, event);
+  return { journalPath: journal.journalPath, events, ...baseline !== void 0 ? { baseline } : {} };
+}
+
 // src/lib/bundle-validate.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
-var JOURNAL_SIDECAR2 = "journal.jsonl";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename2 } from "node:path";
 function validateBundleAt(filePath) {
   const bundle = readBundle(filePath);
   const loose = bundle;
@@ -16059,31 +16655,69 @@ function validateBundleAt(filePath) {
   }
   let sidecarFindings = [];
   let sidecarLoaded = false;
+  const archiveFindings = [];
+  const archivesLoaded = [];
   if (loose.journal === void 0) {
-    const sidecarPath = join2(dirname2(filePath), JOURNAL_SIDECAR2);
-    if (existsSync3(sidecarPath)) {
-      const { events, findings } = parseJournalLines(readFileSync3(sidecarPath, "utf8"));
+    const sidecarPath = journalPathFor(filePath);
+    const folded = [];
+    if (existsSync5(sidecarPath)) {
+      const { events, findings } = parseJournalLines(readFileSync4(sidecarPath, "utf8"));
       sidecarFindings = findings;
       sidecarLoaded = true;
-      loose.journal = events;
+      folded.push(...events);
+    }
+    for (const archivePath of archivePathsFor(sidecarPath)) {
+      const { events, findings } = parseJournalLines(readFileSync4(archivePath, "utf8"));
+      const file2 = basename2(archivePath);
+      for (const finding of findings) archiveFindings.push({ ...finding, file: file2 });
+      archivesLoaded.push(file2);
+      folded.push(...events);
     }
+    if (sidecarLoaded || archivesLoaded.length > 0) loose.journal = folded;
   }
   const nodes = Array.isArray(loose.nodes) ? loose.nodes : [];
   const edges = Array.isArray(loose.edges) ? loose.edges : [];
   const journal = Array.isArray(loose.journal) ? loose.journal : [];
   const result = validateBundle(bundle);
-  const valid = sidecarFindings.length === 0 && result.errors.length === 0;
-  return { bundle, nodes, edges, journal, sidecarLoaded, sidecarFindings, result, valid };
+  const valid = sidecarFindings.length === 0 && archiveFindings.length === 0 && result.errors.length === 0;
+  return {
+    bundle,
+    nodes,
+    edges,
+    journal,
+    sidecarLoaded,
+    sidecarFindings,
+    archivesLoaded,
+    archiveFindings,
+    result,
+    valid
+  };
+}
+function journalLineErrorLines(v) {
+  return [
+    ...v.sidecarFindings.map((f) => `ERROR [${f.rule}] line ${f.line}: ${f.message}`),
+    ...v.archiveFindings.map((f) => `ERROR [${f.rule}] ${f.file} line ${f.line}: ${f.message}`)
+  ];
 }
 export {
   JOURNAL_SIDECAR,
+  KRITIK_ACTOR,
+  VENDORED_PACK,
   appendJournalEvent,
+  appendQualityEvents,
   archivePathFor,
+  archivePathsFor,
   compactSlice,
+  ensureJournalBaseline,
+  journalLineErrorLines,
   journalPathFor,
   loadJournalEvents,
+  loadKritikLibrary,
   nodesByIdOf,
   readBundle,
+  readFullJournalEvents,
   readJournalEvents,
+  resolveJournal,
+  resolvePack,
   validateBundleAt
 };