@cleocode/core 2026.4.50 → 2026.4.51

package/dist/index.js

@@ -9046,12 +9046,13 @@ __export(brain_schema_exports, {
   brainPageEdges: () => brainPageEdges,
   brainPageNodes: () => brainPageNodes,
   brainPatterns: () => brainPatterns,
+  brainPlasticityEvents: () => brainPlasticityEvents,
   brainRetrievalLog: () => brainRetrievalLog,
   brainSchemaMeta: () => brainSchemaMeta,
   brainStickyNotes: () => brainStickyNotes
 });
 import { sql as sql2 } from "drizzle-orm";
-var BRAIN_MEMORY_TIERS, BRAIN_COGNITIVE_TYPES, BRAIN_SOURCE_CONFIDENCE, BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES2, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, BRAIN_STICKY_STATUSES, BRAIN_STICKY_COLORS, BRAIN_STICKY_PRIORITIES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainStickyNotes, brainMemoryLinks, brainSchemaMeta, BRAIN_NODE_TYPES, BRAIN_EDGE_TYPES, brainPageNodes, brainPageEdges, brainRetrievalLog;
+var BRAIN_MEMORY_TIERS, BRAIN_COGNITIVE_TYPES, BRAIN_SOURCE_CONFIDENCE, BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES2, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, BRAIN_STICKY_STATUSES, BRAIN_STICKY_COLORS, BRAIN_STICKY_PRIORITIES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainStickyNotes, brainMemoryLinks, brainSchemaMeta, BRAIN_NODE_TYPES, BRAIN_EDGE_TYPES, brainPageNodes, brainPageEdges, brainRetrievalLog, brainPlasticityEvents;
 var init_brain_schema = __esm({
   "packages/core/src/store/brain-schema.ts"() {
     "use strict";
@@ -9480,8 +9481,11 @@ var init_brain_schema = __esm({
       // Graph bridging (memory ↔ code)
       "references",
       // observation → references → symbol
-      "modified_by"
+      "modified_by",
       // file → modified_by → session
+      // Plasticity (Hebbian + STDP co-retrieval)
+      "co_retrieved"
+      // A → co_retrieved → B (Hebbian: frequently retrieved together)
     ];
     brainPageNodes = sqliteTable(
       "brain_page_nodes",
@@ -9578,6 +9582,37 @@ var init_brain_schema = __esm({
         index("idx_retrieval_log_source").on(table.source)
       ]
     );
+    brainPlasticityEvents = sqliteTable(
+      "brain_plasticity_events",
+      {
+        id: integer("id").primaryKey({ autoIncrement: true }),
+        /** from_id of the affected brain_page_edges row. */
+        sourceNode: text("source_node").notNull(),
+        /** to_id of the affected brain_page_edges row. */
+        targetNode: text("target_node").notNull(),
+        /**
+         * Signed weight delta applied to the edge.
+         * Positive = potentiation (LTP), negative = depression (LTD).
+         */
+        deltaW: real("delta_w").notNull(),
+        /**
+         * STDP event kind: `ltp` (Long-Term Potentiation) or `ltd` (Long-Term
+         * Depression).
+         */
+        kind: text("kind", { enum: ["ltp", "ltd"] }).notNull(),
+        /** ISO 8601 timestamp when this event was applied. */
+        timestamp: text("timestamp").notNull().default(sql2`(datetime('now'))`),
+        /** Session ID that triggered the STDP pass, if available. */
+        sessionId: text("session_id")
+      },
+      (table) => [
+        index("idx_plasticity_source").on(table.sourceNode),
+        index("idx_plasticity_target").on(table.targetNode),
+        index("idx_plasticity_timestamp").on(table.timestamp),
+        index("idx_plasticity_session").on(table.sessionId),
+        index("idx_plasticity_kind").on(table.kind)
+      ]
+    );
   }
 });
 
@@ -14444,6 +14479,14 @@ function runBrainMigrations(nativeDb, db) {
     );
   }
   ensureColumns(nativeDb, "brain_observations", [{ name: "agent", ddl: "text" }], "brain");
+  if (tableExists(nativeDb, "brain_page_edges")) {
+    nativeDb.prepare(
+      `UPDATE brain_page_edges
+         SET edge_type = 'co_retrieved'
+         WHERE edge_type = 'relates_to'
+           AND provenance LIKE 'consolidation:%'`
+    ).run();
+  }
 }
 function loadBrainVecExtension(nativeDb) {
   try {
@@ -20956,6 +20999,160 @@ var init_anthropic_key_resolver = __esm({
   }
 });
 
+// packages/core/src/memory/decision-cross-link.ts
+function extractReferencedSymbols(text3) {
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  for (const match of text3.matchAll(FILE_PATH_RE)) {
+    const raw = match[1];
+    if (!raw) continue;
+    const nodeId = `file:${raw}`;
+    if (seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    refs.push({ raw, nodeId, nodeType: "file", label: raw });
+  }
+  for (const match of text3.matchAll(SYMBOL_RE)) {
+    const raw = match[0];
+    if (!raw || raw.length < 4) continue;
+    if (SYMBOL_STOP_WORDS.has(raw.toLowerCase())) continue;
+    const nodeId = `symbol:${raw}`;
+    if (seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    refs.push({ raw, nodeId, nodeType: "symbol", label: raw });
+  }
+  return refs;
+}
+async function linkDecisionToTargets(projectRoot, decisionId, refs) {
+  const fromId = `decision:${decisionId}`;
+  const writes = refs.map(async (ref) => {
+    await upsertGraphNode(
+      projectRoot,
+      ref.nodeId,
+      ref.nodeType,
+      ref.label,
+      0.5,
+      // placeholder quality until nexus indexes it
+      ref.raw
+    );
+    await addGraphEdge(
+      projectRoot,
+      fromId,
+      ref.nodeId,
+      "applies_to",
+      1,
+      "auto:decision-cross-link"
+    );
+  });
+  await Promise.allSettled(writes);
+}
+async function autoCrossLinkDecision(projectRoot, decisionId, decisionText, rationale) {
+  try {
+    const combined = `${decisionText} ${rationale}`;
+    const refs = extractReferencedSymbols(combined);
+    if (refs.length === 0) return;
+    await linkDecisionToTargets(projectRoot, decisionId, refs);
+  } catch {
+  }
+}
+var FILE_PATH_RE, SYMBOL_RE, SYMBOL_STOP_WORDS;
+var init_decision_cross_link = __esm({
+  "packages/core/src/memory/decision-cross-link.ts"() {
+    "use strict";
+    init_graph_auto_populate();
+    FILE_PATH_RE = /(?:^|[\s`"'([\]{,])((\/[\w.\-/]+|[\w.-]+(?:\/[\w.-]+)+)\.(ts|tsx|js|jsx|rs|json))(?=$|[\s`"')[\]{,])/gm;
+    SYMBOL_RE = /(?<![`"'/\w.])(?:[A-Z][a-zA-Z0-9]{2,}|[a-z][a-zA-Z0-9]*(?:[A-Z][a-zA-Z0-9]*)+|[a-z][a-z0-9]*(?:_[a-z][a-z0-9]*){2,})(?![`"'/\w])/g;
+    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+      "this",
+      "that",
+      "with",
+      "from",
+      "into",
+      "when",
+      "then",
+      "also",
+      "both",
+      "each",
+      "such",
+      "over",
+      "after",
+      "before",
+      "always",
+      "never",
+      "should",
+      "must",
+      "will",
+      "would",
+      "could",
+      "have",
+      "been",
+      "there",
+      "their",
+      "they",
+      "them",
+      "these",
+      "those",
+      "some",
+      "only",
+      "just",
+      "more",
+      "most",
+      "many",
+      "much",
+      "well",
+      "very",
+      "here",
+      "where",
+      "which",
+      "what",
+      "why",
+      "how",
+      "the",
+      "and",
+      "but",
+      "for",
+      "not",
+      "are",
+      "was",
+      "were",
+      "has",
+      "had",
+      "its",
+      "the",
+      "data",
+      "true",
+      "false",
+      "null",
+      "none",
+      "type",
+      "test",
+      "spec",
+      "todo",
+      "fixme",
+      "note",
+      "example",
+      "index",
+      "config",
+      "error",
+      "value",
+      "input",
+      "output",
+      "result",
+      "return",
+      "default",
+      "source",
+      "target",
+      "import",
+      "export",
+      "class",
+      "interface",
+      "function",
+      "const",
+      "async",
+      "await"
+    ]);
+  }
+});
+
 // packages/core/src/memory/decisions.ts
 var decisions_exports = {};
 __export(decisions_exports, {
@@ -21094,6 +21291,8 @@ async function storeDecision(projectRoot, params) {
         "auto:store-decision"
       );
     }
+    autoCrossLinkDecision(projectRoot, saved.id, saved.decision, saved.rationale).catch(() => {
+    });
   } catch {
   }
   detectSupersession(projectRoot, {
@@ -21162,6 +21361,7 @@ var init_decisions2 = __esm({
     init_brain_accessor();
     init_cross_db_cleanup();
     init_sqlite2();
+    init_decision_cross_link();
     init_graph_auto_populate();
     init_quality_scoring();
     init_temporal_supersession();
@@ -42232,6 +42432,30 @@ var init_auto_extract = __esm({
   }
 });
 
+// packages/core/src/memory/edge-types.ts
+var EDGE_TYPES;
+var init_edge_types = __esm({
+  "packages/core/src/memory/edge-types.ts"() {
+    "use strict";
+    EDGE_TYPES = {
+      // Plasticity (Hebbian / STDP co-retrieval)
+      CO_RETRIEVED: "co_retrieved",
+      // Temporal supersession
+      SUPERSEDES: "supersedes",
+      // Task / decision / pattern → target context
+      APPLIES_TO: "applies_to",
+      // Provenance
+      DERIVED_FROM: "derived_from",
+      // Observation → symbol/file impact
+      AFFECTS: "affects",
+      // Observation → symbol name mention
+      MENTIONS: "mentions",
+      // Observation → symbol/file structural link
+      DOCUMENTS: "documents"
+    };
+  }
+});
+
 // packages/core/src/memory/brain-consolidator.ts
 var brain_consolidator_exports = {};
 __export(brain_consolidator_exports, {
@@ -42465,7 +42689,7 @@ function extractSymbolCandidates(text3) {
   const syms = /* @__PURE__ */ new Set();
   for (const m of text3.matchAll(SYMBOL_PATTERN)) {
     const s = m[1];
-    if (s && s.length >= 4 && !SYMBOL_STOP_WORDS.has(s.toLowerCase())) {
+    if (s && s.length >= 4 && !SYMBOL_STOP_WORDS2.has(s.toLowerCase())) {
       syms.add(s);
     }
   }
@@ -42774,7 +42998,7 @@ async function listCodeLinks(projectRoot, limit = 100) {
   }
   return entries;
 }
-var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS;
+var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS2;
 var init_graph_memory_bridge = __esm({
   "packages/core/src/memory/graph-memory-bridge.ts"() {
     "use strict";
@@ -42784,7 +43008,7 @@ var init_graph_memory_bridge = __esm({
     init_typed_query();
     FILE_PATH_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_\-./]+\.(?:ts|tsx|js|jsx|rs|go|py|mjs|cjs))(?:$|\s|['"`)])/g;
     SYMBOL_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*(?:[A-Z][a-zA-Z0-9_]*)+|[a-zA-Z_]{4,}[a-zA-Z0-9_]*)\b/g;
-    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+    SYMBOL_STOP_WORDS2 = /* @__PURE__ */ new Set([
       "true",
       "false",
       "null",
@@ -42828,6 +43052,207 @@ var init_graph_memory_bridge = __esm({
   }
 });
 
+// packages/core/src/memory/brain-stdp.ts
+var brain_stdp_exports = {};
+__export(brain_stdp_exports, {
+  applyStdpPlasticity: () => applyStdpPlasticity,
+  getPlasticityStats: () => getPlasticityStats
+});
+async function applyStdpPlasticity(projectRoot, sessionWindowMs = 5 * 60 * 1e3) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  const result = {
+    ltpEvents: 0,
+    ltdEvents: 0,
+    edgesCreated: 0,
+    pairsExamined: 0
+  };
+  if (!nativeDb) return result;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_retrieval_log LIMIT 1").get();
+  } catch {
+    return result;
+  }
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_plasticity_events LIMIT 1").get();
+  } catch {
+    return result;
+  }
+  const now = Date.now();
+  const cutoffMs = now - sessionWindowMs;
+  const cutoffIso = new Date(cutoffMs).toISOString().replace("T", " ").slice(0, 19);
+  const nowIso = new Date(now).toISOString().replace("T", " ").slice(0, 19);
+  let logRows = [];
+  try {
+    logRows = typedAll(
+      nativeDb.prepare(
+        `SELECT id, entry_ids, created_at, retrieval_order, delta_ms
+         FROM brain_retrieval_log
+         WHERE created_at >= ?
+         ORDER BY created_at ASC, id ASC
+         LIMIT 2000`
+      ),
+      cutoffIso
+    );
+  } catch {
+    return result;
+  }
+  if (logRows.length === 0) return result;
+  const spikes = [];
+  let globalOrder = 0;
+  for (const row of logRows) {
+    let ids;
+    try {
+      ids = JSON.parse(row.entry_ids);
+    } catch {
+      continue;
+    }
+    const rowTime = (/* @__PURE__ */ new Date(row.created_at.replace(" ", "T") + "Z")).getTime();
+    for (const rawId of ids) {
+      const entryId = rawId.includes(":") ? rawId : `observation:${rawId}`;
+      spikes.push({
+        entryId,
+        rowId: row.id,
+        retrievedAt: rowTime,
+        order: row.retrieval_order ?? globalOrder
+      });
+      globalOrder++;
+    }
+  }
+  spikes.sort((a, b) => a.retrievedAt - b.retrievedAt || a.order - b.order);
+  const prepareGetEdge = nativeDb.prepare(
+    `SELECT weight FROM brain_page_edges
+     WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
+  );
+  const prepareUpdateEdge = nativeDb.prepare(
+    `UPDATE brain_page_edges
+     SET weight = MAX(?, MIN(?, weight + ?))
+     WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
+  );
+  const prepareInsertEdge = nativeDb.prepare(
+    `INSERT OR IGNORE INTO brain_page_edges
+       (from_id, to_id, edge_type, weight, provenance, created_at)
+     VALUES (?, ?, 'co_retrieved', ?, 'plasticity:stdp-ltp', ?)`
+  );
+  const prepareLogEvent = nativeDb.prepare(
+    `INSERT INTO brain_plasticity_events
+       (source_node, target_node, delta_w, kind, timestamp)
+     VALUES (?, ?, ?, ?, ?)`
+  );
+  for (let i = 0; i < spikes.length; i++) {
+    const spikeA = spikes[i];
+    for (let j = i + 1; j < spikes.length; j++) {
+      const spikeB = spikes[j];
+      const deltaT = spikeB.retrievedAt - spikeA.retrievedAt;
+      if (deltaT > sessionWindowMs) break;
+      if (spikeA.entryId === spikeB.entryId) continue;
+      result.pairsExamined++;
+      const deltaW = A_PRE * Math.exp(-deltaT / TAU_PRE_MS);
+      if (deltaW < 1e-6) continue;
+      const existingEdge = prepareGetEdge.get(spikeA.entryId, spikeB.entryId);
+      try {
+        if (existingEdge !== void 0) {
+          prepareUpdateEdge.run(WEIGHT_MIN, WEIGHT_MAX, deltaW, spikeA.entryId, spikeB.entryId);
+        } else {
+          const initialWeight = Math.min(WEIGHT_MAX, deltaW);
+          prepareInsertEdge.run(spikeA.entryId, spikeB.entryId, initialWeight, nowIso);
+          result.edgesCreated++;
+        }
+        prepareLogEvent.run(spikeA.entryId, spikeB.entryId, deltaW, "ltp", nowIso);
+        result.ltpEvents++;
+      } catch {
+      }
+      const deltaWNeg = -(A_POST * Math.exp(-deltaT / TAU_POST_MS));
+      const existingReverseEdge = prepareGetEdge.get(spikeB.entryId, spikeA.entryId);
+      if (existingReverseEdge !== void 0 && Math.abs(deltaWNeg) >= 1e-6) {
+        try {
+          prepareUpdateEdge.run(WEIGHT_MIN, WEIGHT_MAX, deltaWNeg, spikeB.entryId, spikeA.entryId);
+          prepareLogEvent.run(spikeB.entryId, spikeA.entryId, deltaWNeg, "ltd", nowIso);
+          result.ltdEvents++;
+        } catch {
+        }
+      }
+    }
+  }
+  return result;
+}
+async function getPlasticityStats(projectRoot, limit = 20) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  const empty = {
+    totalEvents: 0,
+    ltpCount: 0,
+    ltdCount: 0,
+    netDeltaW: 0,
+    lastEventAt: null,
+    recentEvents: []
+  };
+  if (!nativeDb) return empty;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_plasticity_events LIMIT 1").get();
+  } catch {
+    return empty;
+  }
+  let agg;
+  try {
+    agg = nativeDb.prepare(
+      `SELECT
+           COUNT(*)                         AS total,
+           SUM(CASE WHEN kind = 'ltp' THEN 1 ELSE 0 END) AS ltp_count,
+           SUM(CASE WHEN kind = 'ltd' THEN 1 ELSE 0 END) AS ltd_count,
+           SUM(delta_w)                    AS net_delta_w,
+           MAX(timestamp)                  AS last_event_at
+         FROM brain_plasticity_events`
+    ).get();
+  } catch {
+    return empty;
+  }
+  let recentRows = [];
+  try {
+    recentRows = typedAll(
+      nativeDb.prepare(
+        `SELECT id, source_node, target_node, delta_w, kind, timestamp, session_id
+         FROM brain_plasticity_events
+         ORDER BY timestamp DESC, id DESC
+         LIMIT ?`
+      ),
+      limit
+    );
+  } catch {
+  }
+  return {
+    totalEvents: agg?.total ?? 0,
+    ltpCount: agg?.ltp_count ?? 0,
+    ltdCount: agg?.ltd_count ?? 0,
+    netDeltaW: agg?.net_delta_w ?? 0,
+    lastEventAt: agg?.last_event_at ?? null,
+    recentEvents: recentRows.map((r) => ({
+      id: r.id,
+      sourceNode: r.source_node,
+      targetNode: r.target_node,
+      deltaW: r.delta_w,
+      kind: r.kind,
+      timestamp: r.timestamp,
+      sessionId: r.session_id
+    }))
+  };
+}
+var TAU_PRE_MS, TAU_POST_MS, A_PRE, A_POST, WEIGHT_MIN, WEIGHT_MAX;
+var init_brain_stdp = __esm({
+  "packages/core/src/memory/brain-stdp.ts"() {
+    "use strict";
+    init_typed_query();
+    TAU_PRE_MS = 2e4;
+    TAU_POST_MS = 2e4;
+    A_PRE = 0.05;
+    A_POST = 0.06;
+    WEIGHT_MIN = 0;
+    WEIGHT_MAX = 1;
+  }
+});
+
 // packages/core/src/memory/brain-lifecycle.ts
 var brain_lifecycle_exports = {};
 __export(brain_lifecycle_exports, {
@@ -43133,6 +43558,13 @@ async function runConsolidation(projectRoot) {
   } catch (err) {
     console.warn("[consolidation] Step 8 graph memory bridge failed:", err);
   }
+  try {
+    const { applyStdpPlasticity: applyStdpPlasticity2 } = await Promise.resolve().then(() => (init_brain_stdp(), brain_stdp_exports));
+    const stdpResult = await applyStdpPlasticity2(projectRoot);
+    result.stdpPlasticity = stdpResult;
+  } catch (err) {
+    console.warn("[consolidation] Step 9 STDP plasticity failed:", err);
+  }
   return result;
 }
 async function deduplicateByEmbedding(projectRoot) {
@@ -43294,16 +43726,16 @@ async function strengthenCoRetrievedEdges(projectRoot) {
       const updateStmt = nativeDb.prepare(`
         UPDATE brain_page_edges
         SET weight = MIN(1.0, weight + 0.1)
-        WHERE from_id = ? AND to_id = ? AND edge_type = 'relates_to'
+        WHERE from_id = ? AND to_id = ? AND edge_type = ?
       `);
-      const updateResult = updateStmt.run(nodeFrom, nodeTo);
+      const updateResult = updateStmt.run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED);
       const changes = typeof updateResult.changes === "number" ? updateResult.changes : 0;
       if (changes === 0) {
         nativeDb.prepare(`
             INSERT OR IGNORE INTO brain_page_edges
               (from_id, to_id, edge_type, weight, provenance, created_at)
-            VALUES (?, ?, 'relates_to', 0.3, 'consolidation:co-retrieval', ?)
-          `).run(nodeFrom, nodeTo, now);
+            VALUES (?, ?, ?, 0.3, 'consolidation:co-retrieval', ?)
+          `).run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED, now);
       }
       strengthened++;
     } catch {
@@ -43317,6 +43749,7 @@ var init_brain_lifecycle = __esm({
     "use strict";
     init_brain_accessor();
     init_typed_query();
+    init_edge_types();
     STOP_WORDS3 = /* @__PURE__ */ new Set([
       "the",
       "a",
@@ -61645,6 +62078,7 @@ async function listEpicsWithLifecycle(cwd) {
 // packages/core/src/memory/index.ts
 var memory_exports = {};
 __export(memory_exports, {
+  EDGE_TYPES: () => EDGE_TYPES,
   RRF_K: () => RRF_K,
   addResearch: () => addResearch,
   appendExtendedManifest: () => appendExtendedManifest,
@@ -61842,6 +62276,7 @@ function mapImpact(impact) {
 init_brain_retrieval();
 init_brain_search();
 init_decisions2();
+init_edge_types();
 
 // packages/core/src/memory/extraction-gate.ts
 init_brain_embedding();
@@ -70734,6 +71169,7 @@ async function getSyncStatus(remote = "origin", cwd) {
 // packages/core/src/research/index.ts
 var research_exports = {};
 __export(research_exports, {
+  EDGE_TYPES: () => EDGE_TYPES,
   RRF_K: () => RRF_K,
   addResearch: () => addResearch,
   appendExtendedManifest: () => appendExtendedManifest,