@fortemi/core 2026.7.13 → 2026.7.14

package/dist/aiwg-index-shard.js

@@ -1,4 +1,4 @@
-import Ajv2020 from 'ajv/dist/2020.js';
+import Ajv20202 from 'ajv/dist/2020.js';
 import { gzipSync, gunzipSync } from 'fflate';
 import '@noble/hashes/sha256';
 import { blake3 } from '@noble/hashes/blake3';
@@ -153,6 +153,86 @@ function validateOptionalRichMetadata(item, index, errors) {
   if (item.compatibility !== void 0 && !isPlainRecord(item.compatibility)) {
     errors.push("items[" + index + "].compatibility must be an object");
   }
+  if (item.operational_state !== void 0) {
+    const at = "items[" + index + "].operational_state";
+    if (!isPlainRecord(item.operational_state)) {
+      errors.push(at + " must be an object");
+    } else {
+      const state = item.operational_state;
+      const allowedClassifications = /* @__PURE__ */ new Set([
+        "fresh",
+        "historical",
+        "superseded",
+        "contradicted",
+        "needs-source"
+      ]);
+      const allowedConfidence = /* @__PURE__ */ new Set(["source", "candidate", "reviewed", "rejected"]);
+      const stringFields = [
+        "source_repo",
+        "source_kind",
+        "source_id",
+        "observed_state",
+        "observed_at",
+        "source_updated_at",
+        "evidence_url",
+        "evidence_path",
+        "observer",
+        "stale_after"
+      ];
+      const arrayFields = ["supersedes", "contradicts"];
+      const allowedFields = /* @__PURE__ */ new Set([
+        ...stringFields,
+        ...arrayFields,
+        "classification",
+        "confidence",
+        "current_action_selector"
+      ]);
+      if (!allowedClassifications.has(String(state.classification))) {
+        errors.push(at + ".classification must be fresh, historical, superseded, contradicted, or needs-source");
+      }
+      for (const field of stringFields) {
+        if (state[field] !== void 0 && !hasString(state[field])) {
+          errors.push(at + "." + field + " must be a non-empty string");
+        }
+      }
+      for (const field of ["observed_at", "source_updated_at", "stale_after"]) {
+        if (state[field] !== void 0 && (typeof state[field] !== "string" || Number.isNaN(Date.parse(state[field])))) {
+          errors.push(at + "." + field + " must be a date-time string");
+        }
+      }
+      for (const field of arrayFields) {
+        if (!isOptionalStringArray(state[field])) {
+          errors.push(at + "." + field + " must be a string array");
+        }
+      }
+      if (state.confidence !== void 0 && !allowedConfidence.has(String(state.confidence))) {
+        errors.push(at + ".confidence must be source, candidate, reviewed, or rejected");
+      }
+      if (state.current_action_selector !== void 0 && typeof state.current_action_selector !== "boolean") {
+        errors.push(at + ".current_action_selector must be a boolean");
+      }
+      if (Object.keys(state).some((field) => !allowedFields.has(field))) {
+        errors.push(at + " contains unsupported fields");
+      }
+    }
+  }
+  if (item.state_transfer !== void 0) {
+    const at = "items[" + index + "].state_transfer";
+    if (!isPlainRecord(item.state_transfer)) {
+      errors.push(at + " must be an object");
+    } else {
+      const stateTransfer = item.state_transfer;
+      const deletedAt = stateTransfer.deleted_at;
+      if (!Object.hasOwn(stateTransfer, "deleted_at")) {
+        errors.push(at + ".deleted_at is required");
+      } else if (deletedAt !== null && (typeof deletedAt !== "string" || Number.isNaN(Date.parse(deletedAt)))) {
+        errors.push(at + ".deleted_at must be a date-time string or null");
+      }
+      if (Object.keys(stateTransfer).some((field) => field !== "deleted_at")) {
+        errors.push(at + " contains unsupported fields");
+      }
+    }
+  }
 }
 function isPrivacyClassification(value) {
   return value === "private" || value === "sanitized" || value === "public";
@@ -182,7 +262,9 @@ var V2_ONLY_RECORD_FIELDS = [
   "skos_concepts",
   "skos_relations",
   "provenance_events",
-  "compatibility"
+  "compatibility",
+  "operational_state",
+  "state_transfer"
 ];
 var V2_ONLY_SOURCE_FIELDS = ["origin", "generated", "checksum", "updated_at"];
 var V2_ONLY_RELATIONSHIP_FIELDS = ["target_path", "direction", "metadata"];
@@ -292,6 +374,727 @@ function validateAiwgFortemiIndexExport(value) {
   return { valid: errors.length === 0, errors, counts };
 }
 
+// schemas/aiwg-fortemi-index-export.schema.json
+var aiwg_fortemi_index_export_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://aiwg.io/schemas/aiwg-fortemi-index-export.json",
+  title: "AIWG Fortemi Index Export",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "generated_at", "source", "items"],
+  properties: {
+    schema_version: {
+      enum: ["aiwg.fortemi.index.export.v1", "aiwg.fortemi.index.export.v2"]
+    },
+    generated_at: {
+      type: "string",
+      format: "date-time"
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["repo", "privacy"],
+      properties: {
+        repo: {
+          type: "string",
+          minLength: 1
+        },
+        privacy: {
+          $ref: "#/$defs/privacy"
+        },
+        graph: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    compatibility: {
+      type: "object",
+      additionalProperties: false,
+      required: ["previous_schema_version", "strategy"],
+      properties: {
+        previous_schema_version: {
+          const: "aiwg.fortemi.index.export.v1"
+        },
+        strategy: {
+          const: "supported"
+        }
+      }
+    },
+    items: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/record"
+      }
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          schema_version: {
+            const: "aiwg.fortemi.index.export.v1"
+          }
+        }
+      },
+      then: {
+        not: {
+          required: ["compatibility"]
+        },
+        properties: {
+          source: {
+            not: {
+              required: ["graph"]
+            }
+          },
+          items: {
+            items: {
+              allOf: [
+                {
+                  properties: {
+                    schema_version: {
+                      const: "aiwg.fortemi.index.record.v1"
+                    }
+                  }
+                },
+                {
+                  $ref: "#/$defs/v1RecordCompatibility"
+                }
+              ]
+            }
+          }
+        }
+      }
+    },
+    {
+      if: {
+        properties: {
+          schema_version: {
+            const: "aiwg.fortemi.index.export.v2"
+          }
+        }
+      },
+      then: {
+        required: ["compatibility"],
+        properties: {
+          source: {
+            required: ["graph"]
+          },
+          items: {
+            items: {
+              properties: {
+                schema_version: {
+                  const: "aiwg.fortemi.index.record.v2"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ],
+  $defs: {
+    privacy: {
+      enum: ["private", "sanitized", "public"]
+    },
+    recordType: {
+      type: "string",
+      minLength: 1
+    },
+    stringArray: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    numberArray: {
+      type: "array",
+      items: {
+        type: "number"
+      }
+    },
+    v1RecordCompatibility: {
+      type: "object",
+      not: {
+        anyOf: [
+          {
+            required: ["name"]
+          },
+          {
+            required: ["summary"]
+          },
+          {
+            required: ["search"]
+          },
+          {
+            required: ["chunks"]
+          },
+          {
+            required: ["embeddings"]
+          },
+          {
+            required: ["compatibility"]
+          },
+          {
+            required: ["skos_concepts"]
+          },
+          {
+            required: ["skos_relations"]
+          },
+          {
+            required: ["provenance_events"]
+          },
+          {
+            required: ["operational_state"]
+          },
+          {
+            required: ["state_transfer"]
+          }
+        ]
+      },
+      properties: {
+        source: {
+          not: {
+            anyOf: [
+              {
+                required: ["origin"]
+              },
+              {
+                required: ["generated"]
+              },
+              {
+                required: ["checksum"]
+              },
+              {
+                required: ["updated_at"]
+              }
+            ]
+          }
+        },
+        relationships: {
+          items: {
+            not: {
+              anyOf: [
+                {
+                  required: ["target_path"]
+                },
+                {
+                  required: ["direction"]
+                },
+                {
+                  required: ["label"]
+                },
+                {
+                  required: ["confidence"]
+                },
+                {
+                  required: ["privacy"]
+                },
+                {
+                  required: ["metadata"]
+                }
+              ]
+            }
+          }
+        },
+        privacy: {
+          not: {
+            required: ["locality"]
+          }
+        }
+      }
+    },
+    record: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "schema_version",
+        "id",
+        "type",
+        "source",
+        "title",
+        "text",
+        "facets",
+        "tags",
+        "concepts",
+        "relationships",
+        "provenance",
+        "privacy",
+        "updated_at"
+      ],
+      properties: {
+        schema_version: {
+          enum: [
+            "aiwg.fortemi.index.record.v1",
+            "aiwg.fortemi.index.record.v2"
+          ]
+        },
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        type: {
+          $ref: "#/$defs/recordType"
+        },
+        source: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path", "repo_relative_path", "locator"],
+          properties: {
+            path: {
+              type: "string",
+              minLength: 1
+            },
+            repo_relative_path: {
+              type: "string",
+              minLength: 1
+            },
+            locator: {
+              type: "string",
+              minLength: 1
+            },
+            origin: {
+              type: "string",
+              minLength: 1
+            },
+            generated: {
+              type: "boolean"
+            },
+            checksum: {
+              type: "string"
+            },
+            updated_at: {
+              type: "string",
+              format: "date-time"
+            }
+          }
+        },
+        title: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        summary: {
+          type: "string"
+        },
+        text: {
+          type: "string"
+        },
+        search: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "title",
+            "body",
+            "triggers",
+            "aliases",
+            "tags",
+            "frontmatter"
+          ],
+          properties: {
+            title: {
+              type: "string"
+            },
+            name: {
+              type: "string"
+            },
+            summary: {
+              type: "string"
+            },
+            body: {
+              type: "string"
+            },
+            triggers: {
+              $ref: "#/$defs/stringArray"
+            },
+            aliases: {
+              $ref: "#/$defs/stringArray"
+            },
+            capability: {
+              type: "string"
+            },
+            tags: {
+              $ref: "#/$defs/stringArray"
+            },
+            phase: {
+              type: "string"
+            },
+            type: {
+              type: "string"
+            },
+            frontmatter: {
+              type: "object"
+            }
+          }
+        },
+        facets: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        },
+        tags: {
+          $ref: "#/$defs/stringArray"
+        },
+        concepts: {
+          $ref: "#/$defs/stringArray"
+        },
+        relationships: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "target_id"],
+            properties: {
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              target_id: {
+                type: "string",
+                minLength: 1
+              },
+              source_path: {
+                type: "string"
+              },
+              target_path: {
+                type: "string"
+              },
+              direction: {
+                enum: ["upstream", "downstream", "related"]
+              },
+              label: {
+                type: "string"
+              },
+              confidence: {
+                type: "number"
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        provenance: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["field", "source", "path", "confidence", "privacy"],
+            properties: {
+              field: {
+                type: "string",
+                minLength: 1
+              },
+              source: {
+                type: "string",
+                minLength: 1
+              },
+              path: {
+                type: "string",
+                minLength: 1
+              },
+              confidence: {
+                enum: ["source", "candidate", "reviewed", "rejected"]
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              }
+            }
+          }
+        },
+        privacy: {
+          type: "object",
+          additionalProperties: false,
+          required: ["classification", "pii"],
+          properties: {
+            classification: {
+              $ref: "#/$defs/privacy"
+            },
+            pii: {
+              type: "boolean"
+            },
+            locality: {
+              enum: ["project", "framework", "external"]
+            }
+          }
+        },
+        chunks: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              text: {
+                type: "string"
+              },
+              body: {
+                type: "string"
+              },
+              summary: {
+                type: "string"
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              },
+              checksum: {
+                type: "string"
+              }
+            }
+          }
+        },
+        embeddings: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              id: {
+                type: "string"
+              },
+              model: {
+                type: "string"
+              },
+              embedding: {
+                $ref: "#/$defs/numberArray"
+              },
+              vector: {
+                $ref: "#/$defs/numberArray"
+              },
+              granularity: {
+                type: "string"
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              },
+              chunk_id: {
+                type: "string"
+              },
+              vector_ref: {
+                type: "string"
+              },
+              input_hash: {
+                type: "string"
+              }
+            }
+          }
+        },
+        compatibility: {
+          type: "object"
+        },
+        skos_concepts: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "prefLabel"],
+            properties: {
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              prefLabel: {
+                type: "string",
+                minLength: 1
+              },
+              definition: {
+                type: "string"
+              },
+              scheme: {
+                type: "string"
+              },
+              notation: {
+                type: "string"
+              },
+              uri: {
+                type: "string"
+              },
+              altLabels: {
+                $ref: "#/$defs/stringArray"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        skos_relations: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "source_id", "target_id"],
+            properties: {
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              source_id: {
+                type: "string",
+                minLength: 1
+              },
+              target_id: {
+                type: "string",
+                minLength: 1
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        provenance_events: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["activity"],
+            properties: {
+              id: {
+                type: "string"
+              },
+              activity: {
+                type: "string",
+                minLength: 1
+              },
+              agent: {
+                type: "string"
+              },
+              started_at: {
+                type: "string",
+                format: "date-time"
+              },
+              ended_at: {
+                type: "string",
+                format: "date-time"
+              },
+              source: {
+                type: "string"
+              },
+              path: {
+                type: "string"
+              },
+              confidence: {
+                enum: ["source", "candidate", "reviewed", "rejected"]
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              },
+              attributes: {
+                type: "object"
+              }
+            }
+          }
+        },
+        operational_state: {
+          $ref: "#/$defs/operationalState"
+        },
+        state_transfer: {
+          $ref: "#/$defs/stateTransfer"
+        },
+        updated_at: {
+          type: "string",
+          format: "date-time"
+        }
+      }
+    },
+    operationalState: {
+      type: "object",
+      additionalProperties: false,
+      required: ["classification"],
+      properties: {
+        source_repo: { type: "string", minLength: 1 },
+        source_kind: { type: "string", minLength: 1 },
+        source_id: { type: "string", minLength: 1 },
+        observed_state: { type: "string", minLength: 1 },
+        observed_at: { type: "string", format: "date-time" },
+        source_updated_at: { type: "string", format: "date-time" },
+        evidence_url: { type: "string", format: "uri" },
+        evidence_path: { type: "string", minLength: 1 },
+        observer: { type: "string", minLength: 1 },
+        supersedes: { $ref: "#/$defs/stringArray" },
+        contradicts: { $ref: "#/$defs/stringArray" },
+        stale_after: { type: "string", format: "date-time" },
+        classification: {
+          enum: ["fresh", "historical", "superseded", "contradicted", "needs-source"]
+        },
+        confidence: {
+          enum: ["source", "candidate", "reviewed", "rejected"]
+        },
+        current_action_selector: { type: "boolean" }
+      }
+    },
+    stateTransfer: {
+      type: "object",
+      additionalProperties: false,
+      required: ["deleted_at"],
+      properties: {
+        deleted_at: {
+          type: ["string", "null"],
+          format: "date-time"
+        }
+      }
+    }
+  }
+};
+
+// src/aiwg-index-schema.ts
+var ajvInstance;
+var exportValidator;
+function getAjv() {
+  if (!ajvInstance) {
+    ajvInstance = new Ajv20202({
+      allErrors: true,
+      strict: false,
+      validateFormats: false
+    });
+    ajvInstance.addSchema(aiwg_fortemi_index_export_schema_default);
+  }
+  return ajvInstance;
+}
+function formatErrors(errors) {
+  return (errors ?? []).map((error) => {
+    const path = error.instancePath || "(root)";
+    return `${path} ${error.message ?? "is invalid"}`;
+  });
+}
+function getExportValidator() {
+  exportValidator ??= getAjv().getSchema(aiwg_fortemi_index_export_schema_default.$id) ?? getAjv().compile(aiwg_fortemi_index_export_schema_default);
+  return exportValidator;
+}
+function validateAiwgFortemiIndexExportSchema(value) {
+  const validate = getExportValidator();
+  const schemaValue = value && typeof value === "object" && Array.isArray(value.items) ? {
+    ...value,
+    items: value.items.map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+      const schemaRecord = { ...item };
+      Reflect.deleteProperty(schemaRecord, "binary_sources");
+      return schemaRecord;
+    })
+  } : value;
+  const valid = validate(schemaValue);
+  return { valid, errors: formatErrors(validate.errors) };
+}
+
 // src/shard/checksum.ts
 async function sha256Hex(data) {
   const buf = new ArrayBuffer(data.byteLength);
@@ -8658,7 +9461,7 @@ function addCanonicalFormats(ajv) {
 }
 function getCoreAjv() {
   if (!coreAjvInstance) {
-    coreAjvInstance = new Ajv2020({
+    coreAjvInstance = new Ajv20202({
       allErrors: true,
       strict: true,
       validateFormats: true
@@ -8678,7 +9481,7 @@ function getCoreAjv() {
 }
 function getFullAjv() {
   if (!fullAjvInstance) {
-    fullAjvInstance = new Ajv2020({
+    fullAjvInstance = new Ajv20202({
       allErrors: true,
       strict: true,
       validateFormats: true
@@ -8720,7 +9523,7 @@ function fullValidatorFor(name, version = CURRENT_SHARD_VERSION) {
   fullValidators.set(key, validator);
   return validator;
 }
-function formatErrors(errors) {
+function formatErrors2(errors) {
   return (errors ?? []).map((error) => {
     const path = error.instancePath || "(root)";
     return `${path} ${error.message ?? "is invalid"}`;
@@ -8827,7 +9630,7 @@ function validateCoreV1Structure(files, manifest) {
   }
   const manifestValidator = coreValidatorFor("manifest", schemaVersion);
   if (!manifestValidator(manifest)) {
-    return formatErrors(manifestValidator.errors).map((error) => `manifest.json ${error}`);
+    return formatErrors2(manifestValidator.errors).map((error) => `manifest.json ${error}`);
   }
   const components = manifest.components;
   const expectedFiles = new Set(components.map((component) => CORE_V1_COMPONENT_FILES[component].file));
@@ -8854,7 +9657,7 @@ function validateCoreV1Structure(files, manifest) {
     for (const [index, record] of parsed.records.entries()) {
       if (!validator(record)) {
         errors.push(
-          ...formatErrors(validator.errors).map((error) => `${spec.file}[${index}] ${error}`)
+          ...formatErrors2(validator.errors).map((error) => `${spec.file}[${index}] ${error}`)
         );
       }
     }
@@ -8880,7 +9683,7 @@ function validateFullV1Structure(files, manifest) {
   }
   const manifestValidator = fullValidatorFor("manifest", schemaVersion);
   if (!manifestValidator(manifest)) {
-    return formatErrors(manifestValidator.errors).map((error) => `manifest.json ${error}`);
+    return formatErrors2(manifestValidator.errors).map((error) => `manifest.json ${error}`);
   }
   const components = manifest.components;
   const expectedFiles = new Set(
@@ -8909,7 +9712,7 @@ function validateFullV1Structure(files, manifest) {
     for (const [index, record] of parsed.records.entries()) {
       if (!validator(record)) {
         errors.push(
-          ...formatErrors(validator.errors).map((error) => `${spec.file}[${index}] ${error}`)
+          ...formatErrors2(validator.errors).map((error) => `${spec.file}[${index}] ${error}`)
         );
       }
     }
@@ -8945,7 +9748,7 @@ function validateFullV1Structure(files, manifest) {
       const signatureValidator = fullValidatorFor("signature", schemaVersion);
       if (!signatureValidator(signature)) {
         errors.push(
-          ...formatErrors(signatureValidator.errors).map(
+          ...formatErrors2(signatureValidator.errors).map(
             (error) => `signature.json ${error}`
           )
         );
@@ -9825,6 +10628,11 @@ function aiwgRecordContent(record) {
   if (chunks?.length) return chunks.join("\n\n");
   return record.search?.summary ?? "";
 }
+function aiwgRecordCollectionPaths(record) {
+  const segments = record.source.repo_relative_path.split("/").filter((segment) => segment.length > 0 && segment !== ".");
+  const directorySegments = segments.slice(0, -1);
+  return directorySegments.map((_, index) => directorySegments.slice(0, index + 1).join("/"));
+}
 function aiwgShardMetadata(index, record) {
   return {
     aiwg_fortemi_index: {
@@ -9841,31 +10649,61 @@ function aiwgShardMetadata(index, record) {
 function encodeJsonLines(values) {
   return shardEncoder.encode(values.map((value) => JSON.stringify(value)).join("\n"));
 }
+function validateAiwgIndexForShard(index) {
+  const contractValidation = validateAiwgFortemiIndexExportSchema(index);
+  const semanticValidation = validateAiwgFortemiIndexExport(index);
+  const errors = [...contractValidation.errors, ...semanticValidation.errors];
+  if (errors.length > 0) {
+    throw new Error(`Invalid AIWG Fortemi index export:
+${errors.join("\n")}`);
+  }
+}
 async function aiwgFortemiIndexToKnowledgeShard(index, options = {}) {
   if (options.includeNativeRichComponents) {
     throw new Error(
       "Native AIWG full-v1 conversion requires aiwgFortemiIndexToKnowledgeShardWithReport so semantic losses cannot be discarded"
     );
   }
-  const validation = validateAiwgFortemiIndexExport(index);
-  if (!validation.valid) {
-    throw new Error(`Invalid AIWG Fortemi index export:
-${validation.errors.join("\n")}`);
-  }
+  validateAiwgIndexForShard(index);
   if (index.schema_version !== "aiwg.fortemi.index.export.v2") {
     throw new Error("Knowledge Shard conversion requires aiwg.fortemi.index.export.v2");
   }
   const createdAt2 = aiwgShardTimestamp(options.createdAt ?? index.generated_at, (/* @__PURE__ */ new Date()).toISOString());
   const noteIds = new Map(index.items.map((record) => [record.id, aiwgShardUuid("record", record.id)]));
+  const collectionPaths = [...new Set(index.items.flatMap(aiwgRecordCollectionPaths))].sort();
+  const collectionIds = new Map(
+    collectionPaths.map((path) => [path, aiwgShardUuid("collection", path)])
+  );
+  const collectionNoteCounts = /* @__PURE__ */ new Map();
+  for (const record of index.items) {
+    const collectionPath = aiwgRecordCollectionPaths(record).at(-1);
+    if (collectionPath) {
+      collectionNoteCounts.set(collectionPath, (collectionNoteCounts.get(collectionPath) ?? 0) + 1);
+    }
+  }
+  const collections = collectionPaths.map((path) => {
+    const segments = path.split("/");
+    const parentPath = segments.slice(0, -1).join("/");
+    return {
+      id: collectionIds.get(path),
+      name: segments.at(-1),
+      description: null,
+      parent_id: parentPath ? collectionIds.get(parentPath) : null,
+      created_at: createdAt2,
+      note_count: collectionNoteCounts.get(path) ?? 0
+    };
+  });
   const notes = index.items.map((record) => {
     const content = aiwgRecordContent(record);
+    const recordCollectionPaths = aiwgRecordCollectionPaths(record);
+    const collectionPath = recordCollectionPaths.at(-1);
     return {
       id: noteIds.get(record.id),
       title: aiwgRecordTitle(record),
       original_content: content,
       revised_content: content,
       metadata: aiwgShardMetadata(index, record),
-      collection_id: null,
+      collection_id: collectionPath ? collectionIds.get(collectionPath) : null,
       attachments: [],
       format: "markdown",
       source: "aiwg-index",
@@ -9874,7 +10712,7 @@ ${validation.errors.join("\n")}`);
       tags: [...new Set(record.tags)].sort(),
       created_at: aiwgShardTimestamp(record.source.updated_at ?? record.updated_at, createdAt2),
       updated_at: aiwgShardTimestamp(record.updated_at, createdAt2),
-      deleted_at: null
+      deleted_at: record.state_transfer?.deleted_at ?? null
     };
   });
   const links = [];
@@ -9903,21 +10741,22 @@ ${validation.errors.join("\n")}`);
     }
   }
   const files = /* @__PURE__ */ new Map();
-  const components = ["notes", "tags"];
+  const components = ["notes"];
   const counts = {
-    notes: notes.length,
-    tags: [...new Set(notes.flatMap((note) => note.tags))].length
+    notes: notes.length
   };
   files.set("notes.jsonl", encodeJsonLines(notes));
-  files.set("tags.json", shardEncoder.encode(JSON.stringify(
-    [...new Set(notes.flatMap((note) => note.tags))].sort().map((name) => ({ name, created_at: createdAt2 }))
-  )));
   const addComponent = (component, filename, values, jsonLines = true) => {
     if (values.length === 0) return;
     components.push(component);
     counts[component] = values.length;
     files.set(filename, jsonLines ? encodeJsonLines(values) : shardEncoder.encode(JSON.stringify(values)));
   };
+  addComponent("collections", "collections.json", collections, false);
+  const tags = [...new Set(notes.flatMap((note) => note.tags))].sort().map((name) => ({ name, created_at: createdAt2 }));
+  components.push("tags");
+  counts.tags = tags.length;
+  files.set("tags.json", shardEncoder.encode(JSON.stringify(tags)));
   addComponent("links", "links.jsonl", links);
   const checksums = {};
   for (const [filename, bytes] of files) checksums[filename] = await sha256Hex(bytes);
@@ -9956,11 +10795,7 @@ ${validation.errors.join("\n")}`);
   return packTarGz(files);
 }
 async function aiwgFortemiIndexToKnowledgeShardWithReport(index, options = {}) {
-  const validation = validateAiwgFortemiIndexExport(index);
-  if (!validation.valid) {
-    throw new Error(`Invalid AIWG Fortemi index export:
-${validation.errors.join("\n")}`);
-  }
+  validateAiwgIndexForShard(index);
   if (index.schema_version !== "aiwg.fortemi.index.export.v2") {
     throw new Error("Full-v1 Knowledge Shard conversion requires aiwg.fortemi.index.export.v2");
   }