mcp-agents-memory 0.9.25 → 0.9.27

package/build/index.js

@@ -56435,6 +56435,32 @@ function planApplyRecommendations(ids, rows) {
   return plan;
 }
 
+// src/cold_path/project_registry.ts
+var REGISTRY_MEMBER_SQL = "kind IS NOT NULL AND alias_of IS NULL";
+function isUndefinedColumn(err3) {
+  return err3?.code === "42703";
+}
+function parsePTagAnswer(raw) {
+  if (typeof raw !== "string") return { type: "none" };
+  const value = raw.trim();
+  if (!value || value.toLowerCase() === "null") return { type: "none" };
+  if (value.startsWith("NEW:")) {
+    const name = value.slice(4).trim().toLowerCase();
+    return name ? { type: "new", name } : { type: "none" };
+  }
+  return { type: "name", slug: value.toLowerCase() };
+}
+function registryVerdict(answer, canonicalId, registryIds) {
+  if (answer.type === "none") return { accept: null, reason: "no_answer" };
+  if (answer.type === "new") return { accept: null, reason: "new_not_allowed" };
+  if (canonicalId == null) return { accept: null, reason: "unknown_name" };
+  if (!registryIds.has(canonicalId)) return { accept: null, reason: "not_in_registry" };
+  return { accept: canonicalId, reason: "registry" };
+}
+function registryCandidateLines(candidates) {
+  return candidates.map((c) => c.description && c.description.trim() ? `- ${c.name}: ${c.description.trim()}` : `- ${c.name}`).join("\n");
+}
+
 // src/cold_path/dtag_promoter.ts
 function envInt(name, fallback) {
   const raw = process.env[name];
@@ -56442,6 +56468,33 @@ function envInt(name, fallback) {
   const n = Number(raw);
   return Number.isFinite(n) && n >= 1 ? n : fallback;
 }
+async function isRegistryMode() {
+  try {
+    const r = await db.query(`SELECT EXISTS (SELECT 1 FROM project_tags WHERE ${REGISTRY_MEMBER_SQL}) AS on`);
+    return r.rows[0]?.on === true;
+  } catch (err3) {
+    if (!isUndefinedColumn(err3)) throw err3;
+    return false;
+  }
+}
+async function retrotagRegistry(userId, dryRun) {
+  const names = await db.query(
+    `SELECT pt.id, pt.name
+       FROM project_tags pt
+       JOIN project_tags c ON c.id = canonical_project_tag_id(pt.id)
+      WHERE c.kind IS NOT NULL AND c.alias_of IS NULL`
+  );
+  if (dryRun) return 0;
+  let total = 0;
+  for (const r of names.rows) {
+    const n = await retrotag(db, userId, Number(r.id), String(r.name));
+    if (n > 0) {
+      total += n;
+      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] retrotagged ${n} rows with "${r.name}" (registry)`);
+    }
+  }
+  return total;
+}
 var CLASSIFY_SYSTEM = `You review keyword tags from a personal work-memory system and decide whether a tag should become a PROJECT tag.
 
 A PROJECT tag names one specific thing the user's own work is organized around: their product, app, service, brand, company/client, YouTube channel, code repository, or named initiative.
@@ -56548,18 +56601,27 @@ async function runDtagPromotion(opts = {}) {
   const minCount = envInt("DTAG_PROMOTE_MIN_COUNT", 10);
   const windowDays = envInt("DTAG_PROMOTE_WINDOW_DAYS", 30);
   const userId = await getDefaultUserId();
-  const summary = { suggested: [], refreshed: 0, blocked: 0, deferred: 0, superseded: 0, retrotagged: 0 };
+  const registry2 = await isRegistryMode();
+  const summary = { suggested: [], refreshed: 0, blocked: 0, deferred: 0, superseded: 0, retrotagged: 0, registry: registry2 };
   if (!dryRun) summary.superseded = await supersedeExisting(userId);
+  if (registry2) {
+    summary.retrotagged = await retrotagRegistry(userId, dryRun);
+    return summary;
+  }
   const freqResult = await db.query(
-    `SELECT unnest(d_tag) AS tag, COUNT(*)::int AS cnt
-       FROM memory
-      WHERE user_id = $1
-        AND tag_processed = TRUE
-        AND is_active = TRUE
-        AND created_at >= NOW() - ($2 || ' days')::INTERVAL
-      GROUP BY tag
-     HAVING COUNT(*) >= 2
-      ORDER BY cnt DESC
+    `SELECT f.tag, f.cnt
+       FROM (SELECT unnest(d_tag) AS tag, COUNT(*)::int AS cnt
+               FROM memory
+              WHERE user_id = $1
+                AND tag_processed = TRUE
+                AND is_active = TRUE
+                AND created_at >= NOW() - ($2 || ' days')::INTERVAL
+              GROUP BY tag
+             HAVING COUNT(*) >= 2) f
+      WHERE NOT EXISTS (
+              SELECT 1 FROM project_tag_new_suggestions s
+               WHERE s.user_id = $1 AND s.status = 'rejected' AND s.name = lower(btrim(f.tag)))
+      ORDER BY f.cnt DESC
       LIMIT 50`,
     [userId, String(windowDays)]
   );
@@ -56653,6 +56715,19 @@ async function confirmNewTagSuggestion(userId, suggestionId, opts) {
     );
     const created = inserted.rows.length > 0;
     const pTagId = created ? Number(inserted.rows[0].id) : Number((await client2.query(`SELECT id FROM project_tags WHERE name = $1`, [name])).rows[0].id);
+    await client2.query("SAVEPOINT registry_kind");
+    try {
+      await client2.query(
+        `UPDATE project_tags SET kind = 'project', updated_at = NOW()
+          WHERE id = $1 AND kind IS NULL AND alias_of IS NULL
+            AND EXISTS (SELECT 1 FROM project_tags WHERE ${REGISTRY_MEMBER_SQL})`,
+        [pTagId]
+      );
+      await client2.query("RELEASE SAVEPOINT registry_kind");
+    } catch (err3) {
+      await client2.query("ROLLBACK TO SAVEPOINT registry_kind");
+      if (!isUndefinedColumn(err3)) throw err3;
+    }
     const n = await retrotag(client2, userId, pTagId, name);
     await client2.query(
       `UPDATE project_tag_new_suggestions
@@ -56699,6 +56774,7 @@ async function rejectNewTagSuggestion(userId, suggestionId, opts) {
 var GROK_FALLBACK_SPEC = { provider: "xai", model_name: "grok-4-1-fast-non-reasoning" };
 var localFallbackEnabled = process.env.LOCAL_GROK_FALLBACK !== "false";
 var _candidateCache = null;
+var REGISTRY_CANDIDATE_LIMIT = 60;
 var CANDIDATE_CACHE_TTL_MS = 5 * 60 * 1e3;
 function candidateSelectionConfig() {
   const configuredStrategy = process.env.TAGGER_CANDIDATE_STRATEGY?.trim().toLowerCase();
@@ -56712,7 +56788,30 @@ async function listProjectTagCandidates() {
   const cacheKey = `${strategy}:${limit2}`;
   const now = Date.now();
   if (_candidateCache && _candidateCache.key === cacheKey && _candidateCache.expires > now) {
-    return _candidateCache.rows;
+    return _candidateCache.list;
+  }
+  try {
+    const reg = await db.query(
+      `SELECT id, name, description
+         FROM project_tags
+        WHERE ${REGISTRY_MEMBER_SQL}
+        ORDER BY name
+        LIMIT $1`,
+      [REGISTRY_CANDIDATE_LIMIT]
+    );
+    if (reg.rows.length >= REGISTRY_CANDIDATE_LIMIT) {
+      console.error(`\u26A0\uFE0F [Tagger] \uBA85\uBD80\uAC00 ${REGISTRY_CANDIDATE_LIMIT}\uAC1C \uC774\uC0C1 \u2014 \uC774\uB984\uC21C\uC73C\uB85C \uC798\uB9BC. \uBA85\uBD80\uB97C \uC904\uC774\uC138\uC694.`);
+    }
+    if (reg.rows.length > 0) {
+      const list2 = {
+        registry: true,
+        rows: reg.rows.map((row) => ({ id: Number(row.id), name: row.name, description: row.description }))
+      };
+      _candidateCache = { key: cacheKey, list: list2, expires: now + CANDIDATE_CACHE_TTL_MS };
+      return list2;
+    }
+  } catch (err3) {
+    if (!isUndefinedColumn(err3)) throw err3;
   }
   const r = strategy === "frequent" ? await db.query(
     `SELECT pt.id, pt.name, pt.description
@@ -56740,8 +56839,9 @@ async function listProjectTagCandidates() {
     name: row.name,
     description: row.description
   }));
-  _candidateCache = { key: cacheKey, rows, expires: now + CANDIDATE_CACHE_TTL_MS };
-  return rows;
+  const list = { rows, registry: false };
+  _candidateCache = { key: cacheKey, list, expires: now + CANDIDATE_CACHE_TTL_MS };
+  return list;
 }
 function invalidateCandidateCache() {
   _candidateCache = null;
@@ -56770,7 +56870,13 @@ d_tag: 0-3 short lowercase hyphenated keywords about the topic. Skip if no signa
 ROLE: input includes role='user' or role='assistant'. For role='assistant',
   tag the topic; do not treat the reply as a fact about the user.`;
 var SYSTEM_PROMPT = getPrompt("tagger", GENERIC_TAGGER_PROMPT);
-function buildUserPrompt(input, candidates) {
+function buildUserPrompt(input, candidates, registry2 = false) {
+  if (registry2) {
+    return `registry (the ONLY allowed p_tag values \u2014 pick exactly one name, or null if none clearly fits; never invent a name, never use NEW:):
+${registryCandidateLines(candidates)}
+role=${input.role}
+message: ${input.message}`;
+  }
   const candList = candidates.length > 0 ? candidates.map((c) => c.name).join(", ") : "(none)";
   return `candidates: ${candList}
 role=${input.role}
@@ -56799,9 +56905,42 @@ async function getOrCreateProjectTag(name) {
   invalidateCandidateCache();
   return Number(inserted.rows[0].id);
 }
+function registrySchema(candidates) {
+  return {
+    type: "object",
+    properties: {
+      p_tag: { anyOf: [{ type: "string", enum: candidates.map((c) => c.name) }, { type: "null" }] },
+      d_tag: { type: "array", items: { type: "string" }, maxItems: 5 }
+    },
+    required: ["p_tag", "d_tag"],
+    additionalProperties: false
+  };
+}
+async function resolveRegistryAnswer(raw, candidates) {
+  const answer = parsePTagAnswer(raw);
+  let canonicalId = null;
+  if (answer.type === "name") {
+    const chain = await db.query(
+      `WITH RECURSIVE chain AS (
+         SELECT id, alias_of, 0 AS depth FROM project_tags WHERE name = $1
+         UNION ALL
+         SELECT pt.id, pt.alias_of, c.depth + 1 FROM project_tags pt JOIN chain c ON pt.id = c.alias_of
+          WHERE c.depth < 20
+       )
+       SELECT id FROM chain WHERE alias_of IS NULL LIMIT 1`,
+      [answer.slug]
+    );
+    canonicalId = chain.rows.length > 0 ? Number(chain.rows[0].id) : null;
+  }
+  const verdict = registryVerdict(answer, canonicalId, new Set(candidates.map((c) => c.id)));
+  if (verdict.accept == null && verdict.reason !== "no_answer") {
+    console.error(`\u26A0\uFE0F [Tagger] \uBA85\uBD80 \uBAA8\uB4DC: "${String(raw)}" \uBC1B\uC9C0 \uC54A\uC74C (${verdict.reason}). p_tag NULL.`);
+  }
+  return verdict.accept;
+}
 async function tagMessage(input) {
-  const candidates = await listProjectTagCandidates();
-  const userPrompt = buildUserPrompt(input, candidates);
+  const { rows: candidates, registry: registry2 } = await listProjectTagCandidates();
+  const userPrompt = buildUserPrompt(input, candidates, registry2);
   const isLocal = ROLE_REGISTRY.tagger.provider === "local";
   let raw;
   if (isLocal) {
@@ -56810,7 +56949,7 @@ async function tagMessage(input) {
         system: SYSTEM_PROMPT,
         user: userPrompt,
         responseFormat: "json",
-        jsonSchema: TAGGER_SCHEMA,
+        jsonSchema: registry2 ? registrySchema(candidates) : TAGGER_SCHEMA,
         enableThinking: false
         // thinking off — 태거는 단순 매핑 작업. thinking 켜면 reasoning이 모든 토큰 소비해 content 비어버림.
         // jsonSchema → llama.cpp grammar로 <think> bleed 차단 (Qwen3 bug #20345).
@@ -56852,7 +56991,9 @@ async function tagMessage(input) {
   }
   let p_tag_id = null;
   let newly_created_p_tag_name;
-  if (parsed.p_tag && typeof parsed.p_tag === "string") {
+  if (registry2) {
+    p_tag_id = await resolveRegistryAnswer(parsed.p_tag, candidates);
+  } else if (parsed.p_tag && typeof parsed.p_tag === "string") {
     if (parsed.p_tag.startsWith("NEW:")) {
       const newName = parsed.p_tag.slice(4).trim();
       if (newName && await isBlockedNewTagName(newName)) {
@@ -58946,6 +59087,7 @@ async function applyAliasSuggestion(suggestionId, opts = {}) {
 }
 
 // src/tools/manage_project_tags.ts
+var REGISTRY_DESCRIPTION_MAX = 200;
 var DEFAULT_LIMIT2 = 20;
 var MAX_LIMIT = 100;
 var statusSchema = external_exports.enum([
@@ -59004,6 +59146,20 @@ async function lookupSuggestionForUser(userId, suggestionId) {
     status: String(result.rows[0].status)
   };
 }
+async function registrySourceError(tagId, tagName) {
+  try {
+    const r = await db.query(`SELECT kind FROM project_tags WHERE id = $1`, [tagId]);
+    if (r.rows[0]?.kind != null) {
+      return toolError(
+        "source tag is in the project registry; aliasing it would silently drop it from the registry. Unregister it first, or alias the other tag into it.",
+        { source_tag: tagName }
+      );
+    }
+  } catch (err3) {
+    if (err3?.code !== "42703") throw err3;
+  }
+  return null;
+}
 async function listSuggestions(userId, status, limit2) {
   const result = await db.query(
     `SELECT s.id,
@@ -59050,6 +59206,14 @@ async function confirmAlias(userId, suggestionId, reason) {
       status: suggestion.status
     });
   }
+  const src = await db.query(
+    `SELECT s.source_tag_id, pt.name FROM project_tag_alias_suggestions s JOIN project_tags pt ON pt.id = s.source_tag_id WHERE s.id = $1`,
+    [suggestionId]
+  );
+  if (src.rows.length > 0) {
+    const blocked = await registrySourceError(Number(src.rows[0].source_tag_id), String(src.rows[0].name));
+    if (blocked) return blocked;
+  }
   const result = await applyAliasSuggestion(suggestionId, {
     decidedBy: "user",
     reason
@@ -59168,6 +59332,91 @@ async function applyRecommendations(userId, ids, reason) {
     failed
   });
 }
+async function listRegistry(userId) {
+  const result = await db.query(
+    `SELECT pt.name, pt.kind, pt.paused, pt.description, pt.alias_of,
+            (SELECT string_agg(a.name, ',' ORDER BY a.name) FROM project_tags a WHERE a.alias_of = pt.id) AS aliases,
+            (SELECT count(*) FROM memory m
+              WHERE m.user_id = $1 AND m.is_active = TRUE AND m.p_tag_id IS NOT NULL
+                AND m.created_at >= NOW() - INTERVAL '30 days'
+                AND canonical_project_tag_id(m.p_tag_id) = pt.id)::int AS uses_30d
+       FROM project_tags pt
+      WHERE pt.kind IS NOT NULL
+      ORDER BY pt.kind, pt.paused, pt.name`,
+    [userId]
+  );
+  const entries = result.rows.map((r) => ({
+    name: String(r.name),
+    kind: String(r.kind),
+    paused: r.paused === true,
+    description: r.description ?? null,
+    aliases: r.aliases ? String(r.aliases).split(",") : [],
+    uses_30d: Number(r.uses_30d),
+    // 명부 항목이 다른 태그의 별칭이 되면 태거 후보에서 빠진다 — 보이게 표시
+    ...r.alias_of != null ? { warning: "this entry is now an alias of another tag, so it is NOT offered to the tagger" } : {}
+  }));
+  return ok2({
+    action: "list_registry",
+    registry_mode: entries.some((e) => !e.warning),
+    count: entries.length,
+    entries
+  });
+}
+async function registerProject(userId, tagName, description, kind, paused) {
+  const name = normalizeTagName(tagName);
+  if (!name) return toolError("tag is required for register_project");
+  const desc = description?.trim();
+  if (!desc) return toolError("description is required for register_project (one line: what belongs here)");
+  if (desc.length > REGISTRY_DESCRIPTION_MAX) {
+    return toolError(`description is too long (max ${REGISTRY_DESCRIPTION_MAX} chars) \u2014 the tagger reads it on every call`);
+  }
+  const result = await db.query(
+    `INSERT INTO project_tags (name, kind, description, paused)
+     VALUES ($1, COALESCE($2, 'project'), $3, COALESCE($4, FALSE))
+     ON CONFLICT (name) DO UPDATE
+       SET kind = COALESCE($2, project_tags.kind, 'project'),
+           description = EXCLUDED.description,
+           paused = COALESCE($4, project_tags.paused),
+           updated_at = NOW()
+       WHERE project_tags.alias_of IS NULL
+     RETURNING id, kind, paused, (xmax = 0) AS created`,
+    [name, kind ?? null, desc, paused ?? null]
+  );
+  if (result.rows.length === 0) {
+    return toolError("tag is an alias of another tag; register the canonical tag instead", { tag: name });
+  }
+  await db.query(
+    `UPDATE project_tag_new_suggestions
+        SET status = 'superseded', decided_by = 'user', decision_reason = 'registered as project',
+            decided_at = NOW(), project_tag_id = $2, updated_at = NOW()
+      WHERE user_id = $1 AND name = $3 AND status = 'pending'`,
+    [userId, Number(result.rows[0].id), name]
+  );
+  invalidateCandidateCache();
+  const row = result.rows[0];
+  return ok2({
+    action: "register_project",
+    tag: name,
+    kind: String(row.kind),
+    paused: row.paused === true,
+    description: desc,
+    project_tag_id: Number(row.id),
+    created: row.created === true
+  });
+}
+async function unregisterProject(tagName) {
+  const name = normalizeTagName(tagName);
+  if (!name) return toolError("tag is required for unregister_project");
+  const result = await db.query(
+    `UPDATE project_tags SET kind = NULL, paused = FALSE, updated_at = NOW()
+      WHERE name = $1 AND kind IS NOT NULL
+     RETURNING id`,
+    [name]
+  );
+  if (result.rows.length === 0) return toolError("tag is not in the registry", { tag: name });
+  invalidateCandidateCache();
+  return ok2({ action: "unregister_project", tag: name, removed: true });
+}
 async function setAlias(userId, sourceTagName, targetTagName, reason) {
   const sourceName = normalizeTagName(sourceTagName);
   const targetName = normalizeTagName(targetTagName);
@@ -59187,6 +59436,8 @@ async function setAlias(userId, sourceTagName, targetTagName, reason) {
       target_tag: targetTag.name
     });
   }
+  const blocked = await registrySourceError(sourceTag.id, sourceTag.name);
+  if (blocked) return blocked;
   const insertResult = await db.query(
     `INSERT INTO project_tag_alias_suggestions (
        user_id,
@@ -59297,7 +59548,12 @@ Alias suggestions (two existing tags look like the same project):
   - set_alias: manually set source_tag as an alias of target_tag through a pending suggestion + applyAliasSuggestion().
   - unset_alias: clear alias_of for one project tag.
 
-New project tag suggestions (a frequent d_tag that is not a project tag yet; ids are separate from alias ids):
+Project registry (the short, human-chosen list the tagger picks from \u2014 DEVLOG \xA724). When the registry has at least one entry, the tagger only assigns registry tags (or their aliases) and never invents names:
+  - list_registry: show registry entries (kind, paused, description, aliases, 30-day uses).
+  - register_project: add or update an entry. tag + description (one line: what belongs here) required; kind = project (default) or category (not a project but a standing bucket, e.g. personal facts); paused = true keeps it as a tagger candidate but hides it from "active projects".
+  - unregister_project: take a tag off the registry (the tag and its old memories stay).
+
+New project tag suggestions (a frequent d_tag that is not a project tag yet; ids are separate from alias ids; not created while the registry is in use):
   - list_new_tags: list them by status (pending / confirmed / rejected / superseded). Each has a recommendation (project / generic / unsure) and uses = how often that d_tag was used in the window.
   - confirm_new_tag: create the project tag and retro-tag untagged memories carrying that exact d_tag.
   - reject_new_tag: reject it; a rejected name is never suggested again.
@@ -59312,7 +59568,10 @@ New project tag suggestions (a frequent d_tag that is not a project tag yet; ids
           "list_new_tags",
           "confirm_new_tag",
           "reject_new_tag",
-          "apply_recommendations"
+          "apply_recommendations",
+          "list_registry",
+          "register_project",
+          "unregister_project"
         ]).describe("\uC791\uC5C5 \uC885\uB958"),
         status: statusSchema.optional().describe("list_suggestions / list_new_tags status filter (default pending)"),
         limit: external_exports.number().int().min(1).max(MAX_LIMIT).optional().describe(`list_suggestions / list_new_tags limit (default ${DEFAULT_LIMIT2})`),
@@ -59321,7 +59580,10 @@ New project tag suggestions (a frequent d_tag that is not a project tag yet; ids
         reason: external_exports.string().optional().describe("confirm/reject/set decision reason"),
         source_tag: external_exports.string().optional().describe("set_alias source project_tags.name"),
         target_tag: external_exports.string().optional().describe("set_alias target project_tags.name"),
-        tag: external_exports.string().optional().describe("unset_alias \uB300\uC0C1 project_tags.name")
+        tag: external_exports.string().optional().describe("unset_alias / register_project / unregister_project \uB300\uC0C1 project_tags.name"),
+        description: external_exports.string().optional().describe("register_project: \uD55C \uC904 \uC124\uBA85(\uBB34\uC5C7\uC774 \uC5EC\uAE30 \uC18D\uD558\uB098) \u2014 \uD0DC\uAC70 \uC548\uB0B4\uBB38"),
+        kind: external_exports.enum(["project", "category"]).optional().describe("register_project: project(\uAE30\uBCF8) \uB610\uB294 category"),
+        paused: external_exports.boolean().optional().describe("register_project: \uBA48\uCD98 \uD504\uB85C\uC81D\uD2B8\uBA74 true")
       }
     },
     async (args) => {
@@ -59352,6 +59614,15 @@ New project tag suggestions (a frequent d_tag that is not a project tag yet; ids
         if (args.action === "unset_alias") {
           return unsetAlias(userId, args.tag);
         }
+        if (args.action === "list_registry") {
+          return listRegistry(userId);
+        }
+        if (args.action === "register_project") {
+          return registerProject(userId, args.tag, args.description, args.kind, args.paused);
+        }
+        if (args.action === "unregister_project") {
+          return unregisterProject(args.tag);
+        }
         if (args.action === "list_new_tags") {
           return listNewTags(userId, args.status ?? "pending", args.limit ?? DEFAULT_LIMIT2);
         }
@@ -59414,8 +59685,7 @@ async function collectBrief(opts = {}) {
       LIMIT $2`,
     [userId, PINNED_LIMIT]
   );
-  const ptags = await db.query(
-    `SELECT cpt.name,
+  const activeSql = (registryFilter) => `SELECT cpt.name,
             COUNT(*)::int AS cnt,
             MAX(m.created_at) AS last_used
        FROM memory m
@@ -59423,11 +59693,24 @@ async function collectBrief(opts = {}) {
       WHERE m.user_id = $1
         AND m.is_active = TRUE
         AND m.created_at >= NOW() - ($2 || ' days')::INTERVAL
+        ${registryFilter}
       GROUP BY cpt.name
       ORDER BY MAX(m.created_at) DESC
-      LIMIT $3`,
-    [userId, String(shortTermDays), ACTIVE_PTAG_LIMIT]
-  );
+      LIMIT $3`;
+  const activeParams = [userId, String(shortTermDays), ACTIVE_PTAG_LIMIT];
+  let ptags;
+  try {
+    ptags = await db.query(
+      activeSql(`AND (NOT EXISTS (SELECT 1 FROM project_tags r WHERE r.kind IS NOT NULL AND r.alias_of IS NULL)
+                      OR (cpt.kind = 'project' AND NOT cpt.paused))`),
+      activeParams
+    );
+  } catch (err3) {
+    if (err3?.code !== "42703") {
+      console.error("\u26A0\uFE0F [Brief] \uBA85\uBD80 \uD544\uD130 \uCFFC\uB9AC \uC2E4\uD328, \uD544\uD130 \uC5C6\uC774 \uD45C\uC2DC:", err3?.message ?? err3);
+    }
+    ptags = await db.query(activeSql(""), activeParams);
+  }
   let recentCurrent = [];
   let recentOthers = [];
   if (currentPlatform) {
@@ -61741,7 +62024,7 @@ async function maybeRunPromotion() {
   try {
     const result = await runDtagPromotion();
     if (result.suggested.length > 0 || result.retrotagged > 0 || result.superseded > 0 || result.deferred > 0) {
-      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] suggested=${result.suggested.length}, refreshed=${result.refreshed}, blocked=${result.blocked}, deferred=${result.deferred}, superseded=${result.superseded}, retrotagged=${result.retrotagged} rows`);
+      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] ${result.registry ? "registry " : ""}suggested=${result.suggested.length}, refreshed=${result.refreshed}, blocked=${result.blocked}, deferred=${result.deferred}, superseded=${result.superseded}, retrotagged=${result.retrotagged} rows`);
     }
   } catch (err3) {
     console.error("\u26A0\uFE0F [DTagPromoter] promotion error (non-blocking):", err3);