mcp-agents-memory 0.9.23 → 0.9.25

package/build/index.js

@@ -56411,6 +56411,290 @@ function getPrompt(name, fallback) {
   return fallback;
 }
 
+// src/cold_path/dtag_promoter.ts
+init_db();
+init_users();
+
+// src/cold_path/dtag_suggest_gate.ts
+function normalizeTag(name) {
+  return String(name ?? "").toLowerCase().trim();
+}
+function parseRecommendation(value) {
+  return value === "project" || value === "generic" || value === "unsure" ? value : null;
+}
+function planApplyRecommendations(ids, rows) {
+  const byId = new Map(rows.map((r) => [r.id, r]));
+  const plan = { confirm: [], reject: [], keep: [], skipped: [] };
+  for (const id of [...new Set(ids)]) {
+    const row = byId.get(id);
+    if (!row || row.status !== "pending") plan.skipped.push(id);
+    else if (row.recommendation === "project") plan.confirm.push(id);
+    else if (row.recommendation === "generic") plan.reject.push(id);
+    else plan.keep.push(id);
+  }
+  return plan;
+}
+
+// src/cold_path/dtag_promoter.ts
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 1 ? n : fallback;
+}
+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.
+NOT a project: generic activities or topics (bug, fix, upload, login, review, approval, logging, error-handling, translation, policy), feature or UI words, and third-party tools/platforms/OSes the user merely uses (windows, ubuntu, photoshop, cloudflare, playwright, app-store) \u2014 unless the samples show the user is building something with that exact name.
+
+Answer:
+- "project": clearly a specific named thing of the user's own work.
+- "generic": clearly a generic word or a third-party tool merely used.
+- "unsure": a specific name, but the samples do not make clear whether it is the user's own project or just a tool/platform they use.
+Never answer "generic" for a specific proper name (a brand, product, app or company name) \u2014 use "unsure" instead.
+reason: one short sentence (max 60 characters) in the same language as the samples.
+
+OUTPUT strict JSON object: { "verdict": "project" | "generic" | "unsure", "reason": "<short sentence>" }`;
+var CLASSIFY_SCHEMA = {
+  type: "object",
+  properties: {
+    verdict: { type: "string", enum: ["project", "generic", "unsure"] },
+    reason: { type: "string" }
+  },
+  required: ["verdict", "reason"],
+  additionalProperties: false
+};
+var CLASSIFY_SAMPLE_LIMIT = 3;
+var CLASSIFY_SAMPLE_CHARS = 160;
+async function classifyCandidate(userId, name, uses, windowDays) {
+  try {
+    const samples = await db.query(
+      `SELECT left(regexp_replace(message, '\\s+', ' ', 'g'), $3) AS preview
+         FROM memory
+        WHERE user_id = $1
+          AND d_tag @> ARRAY[$2]::text[]
+          AND role = 'user'
+          AND is_active = TRUE
+        ORDER BY created_at DESC
+        LIMIT $4`,
+      [userId, name, CLASSIFY_SAMPLE_CHARS, CLASSIFY_SAMPLE_LIMIT]
+    );
+    const lines = samples.rows.map((r) => `- ${r.preview}`).join("\n") || "(none)";
+    const raw = await callRole("clusterer", {
+      system: CLASSIFY_SYSTEM,
+      user: `tag: ${name}
+uses (${windowDays} days): ${uses}
+recent user messages with this tag:
+${lines}`,
+      responseFormat: "json",
+      // local 외 프로바이더용 (local은 jsonSchema가 우선)
+      jsonSchema: CLASSIFY_SCHEMA,
+      enableThinking: false,
+      maxTokens: 200
+    });
+    const obj = JSON.parse(raw);
+    const recommendation = parseRecommendation(obj?.verdict);
+    if (!recommendation) throw new Error(`unexpected verdict: ${String(obj?.verdict).slice(0, 40)}`);
+    return { recommendation, rationale: String(obj?.reason ?? "").slice(0, 300) };
+  } catch (err3) {
+    console.error(`\u26A0\uFE0F [DTagPromoter] classify "${name}" failed, will retry next run:`, err3);
+    return null;
+  }
+}
+async function supersedeExisting(userId) {
+  const result = await db.query(
+    `UPDATE project_tag_new_suggestions s
+        SET status = 'superseded',
+            decided_by = 'system',
+            decision_reason = 'project tag already exists',
+            decided_at = NOW(),
+            project_tag_id = pt.id,
+            updated_at = NOW()
+       FROM project_tags pt
+      WHERE s.user_id = $1
+        AND s.status = 'pending'
+        AND pt.name = s.name
+     RETURNING s.id`,
+    [userId]
+  );
+  return result.rows.length;
+}
+async function retrotag(client2, userId, pTagId, tag) {
+  const updated = await client2.query(
+    `UPDATE memory
+        SET p_tag_id = $1, updated_at = NOW()
+      WHERE user_id = $2
+        AND tag_processed = TRUE
+        AND p_tag_id IS NULL
+        AND d_tag @> ARRAY[$3]::text[]
+     RETURNING id`,
+    [pTagId, userId, tag]
+  );
+  return updated.rows.length;
+}
+async function isBlockedNewTagName(name) {
+  try {
+    const r = await db.query(
+      `SELECT 1 FROM project_tag_new_suggestions WHERE name = $1 AND status IN ('pending', 'rejected') LIMIT 1`,
+      [normalizeTag(name)]
+    );
+    return r.rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function runDtagPromotion(opts = {}) {
+  const dryRun = opts.dryRun === true;
+  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 };
+  if (!dryRun) summary.superseded = await supersedeExisting(userId);
+  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
+      LIMIT 50`,
+    [userId, String(windowDays)]
+  );
+  const candidates = freqResult.rows.map((r) => ({ tag: normalizeTag(r.tag), cnt: Number(r.cnt) })).filter((t) => t.tag.length > 0 && t.cnt >= minCount);
+  if (candidates.length === 0) return summary;
+  const names = candidates.map((c) => c.tag);
+  const existing = new Map((await db.query(
+    `SELECT name, id FROM project_tags WHERE name = ANY($1::text[])`,
+    [names]
+  )).rows.map((r) => [String(r.name), Number(r.id)]));
+  const prior = new Map((await db.query(
+    `SELECT name, id, status FROM project_tag_new_suggestions WHERE user_id = $1 AND name = ANY($2::text[])`,
+    [userId, names]
+  )).rows.map((r) => [String(r.name), { id: Number(r.id), status: String(r.status) }]));
+  for (const { tag, cnt } of candidates) {
+    const row = prior.get(tag);
+    if (row?.status === "rejected") {
+      summary.blocked++;
+      continue;
+    }
+    const pTagId = existing.get(tag);
+    if (pTagId != null) {
+      if (dryRun) continue;
+      const n = await retrotag(db, userId, pTagId, tag);
+      if (n > 0) {
+        summary.retrotagged += n;
+        console.error(`\u{1F3F7}\uFE0F [DTagPromoter] retrotagged ${n} rows with "${tag}"`);
+      }
+      continue;
+    }
+    if (row) {
+      if (row.status !== "pending") {
+        summary.blocked++;
+        continue;
+      }
+      if (dryRun) continue;
+      const touched = await db.query(
+        `UPDATE project_tag_new_suggestions
+            SET uses = $2, last_seen_at = NOW(), updated_at = NOW()
+          WHERE id = $1 AND status = 'pending'
+         RETURNING id`,
+        [row.id, cnt]
+      );
+      if (touched.rows.length > 0) summary.refreshed++;
+      continue;
+    }
+    const verdict = await classifyCandidate(userId, tag, cnt, windowDays);
+    if (!verdict) {
+      summary.deferred++;
+      continue;
+    }
+    const preview = { name: tag, uses: cnt, ...verdict };
+    if (!dryRun) {
+      const spec = ROLE_REGISTRY.clusterer;
+      const inserted = await db.query(
+        `INSERT INTO project_tag_new_suggestions
+           (user_id, name, uses, recommendation, rationale, model_provider, model_name)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (user_id, name) DO NOTHING
+         RETURNING id`,
+        [userId, preview.name, preview.uses, preview.recommendation, preview.rationale, spec.provider, spec.model_name]
+      );
+      if (inserted.rows.length === 0) continue;
+      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] suggested "${preview.name}" (uses=${preview.uses}, recommendation=${preview.recommendation})`);
+    }
+    summary.suggested.push(preview);
+  }
+  return summary;
+}
+async function confirmNewTagSuggestion(userId, suggestionId, opts) {
+  const client2 = await db.getClient();
+  try {
+    await client2.query("BEGIN");
+    const row = await client2.query(
+      `SELECT id, name, status FROM project_tag_new_suggestions
+        WHERE id = $1 AND user_id = $2 FOR UPDATE`,
+      [suggestionId, userId]
+    );
+    if (row.rows.length === 0) {
+      await client2.query("ROLLBACK");
+      return { suggestion_id: suggestionId, name: "", status: "missing", error: "suggestion_id not found for current user" };
+    }
+    const { name, status } = row.rows[0];
+    if (status !== "pending") {
+      await client2.query("ROLLBACK");
+      return { suggestion_id: suggestionId, name, status, error: "suggestion is not pending" };
+    }
+    const inserted = await client2.query(
+      `INSERT INTO project_tags (name) VALUES ($1) ON CONFLICT (name) DO NOTHING RETURNING id`,
+      [name]
+    );
+    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);
+    const n = await retrotag(client2, userId, pTagId, name);
+    await client2.query(
+      `UPDATE project_tag_new_suggestions
+          SET status = 'confirmed', decided_by = $2, decision_reason = $3, decided_at = NOW(),
+              project_tag_id = $4, retrotagged = $5, updated_at = NOW()
+        WHERE id = $1`,
+      [suggestionId, opts.decidedBy, opts.reason ?? null, pTagId, n]
+    );
+    await client2.query("COMMIT");
+    invalidateCandidateCache();
+    return { suggestion_id: suggestionId, name, status: "confirmed", project_tag_id: pTagId, created, retrotagged: n };
+  } catch (err3) {
+    try {
+      await client2.query("ROLLBACK");
+    } catch {
+    }
+    throw err3;
+  } finally {
+    client2.release();
+  }
+}
+async function rejectNewTagSuggestion(userId, suggestionId, opts) {
+  const result = await db.query(
+    `UPDATE project_tag_new_suggestions
+        SET status = 'rejected', decided_by = $3, decision_reason = $4, decided_at = NOW(), updated_at = NOW()
+      WHERE id = $1 AND user_id = $2 AND status = 'pending'
+     RETURNING id, name, status`,
+    [suggestionId, userId, opts.decidedBy, opts.reason ?? null]
+  );
+  if (result.rows.length > 0) {
+    return { suggestion_id: suggestionId, name: String(result.rows[0].name), status: "rejected" };
+  }
+  const row = await db.query(
+    `SELECT name, status FROM project_tag_new_suggestions WHERE id = $1 AND user_id = $2`,
+    [suggestionId, userId]
+  );
+  if (row.rows.length === 0) {
+    return { suggestion_id: suggestionId, name: "", status: "missing", error: "suggestion_id not found for current user" };
+  }
+  return { suggestion_id: suggestionId, name: String(row.rows[0].name), status: String(row.rows[0].status), error: "suggestion is not pending" };
+}
+
 // src/cold_path/tagger.ts
 var GROK_FALLBACK_SPEC = { provider: "xai", model_name: "grok-4-1-fast-non-reasoning" };
 var localFallbackEnabled = process.env.LOCAL_GROK_FALLBACK !== "false";
@@ -56571,7 +56855,9 @@ async function tagMessage(input) {
   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) {
+      if (newName && await isBlockedNewTagName(newName)) {
+        console.error(`\u26A0\uFE0F [Tagger] "${newName}"\uC740(\uB294) \uC0C8 \uD0DC\uADF8 \uC81C\uC548\uC5D0\uC11C \uC0AC\uB78C\uC758 \uACB0\uC815\uC744 \uAE30\uB2E4\uB9AC\uAC70\uB098 \uBC18\uB824\uB41C \uC774\uB984\uC774\uB77C \uB9CC\uB4E4\uC9C0 \uC54A\uC74C. p_tag NULL.`);
+      } else if (newName) {
         p_tag_id = await getOrCreateProjectTag(newName);
         newly_created_p_tag_name = newName;
       }
@@ -57524,6 +57810,51 @@ init_users();
 // src/cold_path/project_alias_promoter.ts
 init_db();
 init_users();
+
+// src/cold_path/alias_reject_gate.ts
+function pairKey(a, b) {
+  return a < b ? `${a}:${b}` : `${b}:${a}`;
+}
+function groupPairHistory(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (r.sourceId === r.targetId) continue;
+    const k = pairKey(r.sourceId, r.targetId);
+    const list = out.get(k);
+    if (list) list.push(r);
+    else out.set(k, [r]);
+  }
+  return out;
+}
+var isUserRejection = (r) => r.status === "rejected" && r.decidedBy === "user";
+function userRejectedDirection(rows, sourceId, targetId) {
+  let hit = null;
+  for (const r of rows ?? []) {
+    if (!isUserRejection(r) || r.sourceId !== sourceId || r.targetId !== targetId) continue;
+    if (!hit || r.decidedAt.getTime() > hit.decidedAt.getTime()) hit = r;
+  }
+  return hit ? hit.id : null;
+}
+function skipBeforeJudge(rows) {
+  const all = rows ?? [];
+  const rejections = all.filter(isUserRejection);
+  if (rejections.length === 0) return false;
+  const { sourceId: a, targetId: b } = rejections[0];
+  if (userRejectedDirection(all, a, b) !== null && userRejectedDirection(all, b, a) !== null) return true;
+  const lastRejection = Math.max(...rejections.map((r) => r.decidedAt.getTime()));
+  return all.some((r) => !isUserRejection(r) && r.createdAt.getTime() > lastRejection);
+}
+function repeatsToSweep(rows) {
+  const out = [];
+  for (const r of rows ?? []) {
+    if (r.status !== "pending" || r.manual) continue;
+    const rejectedId = userRejectedDirection(rows, r.sourceId, r.targetId);
+    if (rejectedId !== null) out.push({ pendingId: r.id, rejectedId });
+  }
+  return out;
+}
+
+// src/cold_path/project_alias_promoter.ts
 var QUALIFYING_RELATIONS = /* @__PURE__ */ new Set([
   "rename",
   "alias",
@@ -57595,7 +57926,7 @@ OUTPUT strict JSON only:
 - If only a few memories are filed under the wrong tag, use "misfile_suspected".
 - evidence_memory_ids and conflict_memory_ids must only use supplied memory ids.`;
 var JUDGE_SYSTEM_PROMPT = getPrompt("alias_judge", GENERIC_ALIAS_JUDGE_PROMPT);
-function envInt(name, fallback) {
+function envInt2(name, fallback) {
   const raw = process.env[name];
   if (!raw) return fallback;
   const n = Number(raw);
@@ -57675,9 +58006,6 @@ function nameSimilarity(a, b) {
   const dice = bigramDice(a, b);
   return Math.max(tokenScore, dice);
 }
-function pairKey(a, b) {
-  return a < b ? `${a}:${b}` : `${b}:${a}`;
-}
 function uniqueSortedNumbers(values) {
   return Array.from(new Set(values)).sort((a, b) => a - b);
 }
@@ -57693,8 +58021,8 @@ function tagPayload(tag) {
   };
 }
 function isNewOrLowFrequency(tag) {
-  const lowMax = envInt("PROJECT_ALIAS_LOW_COUNT_MAX", 3);
-  const newDays = envInt("PROJECT_ALIAS_NEW_TAG_DAYS", 14);
+  const lowMax = envInt2("PROJECT_ALIAS_LOW_COUNT_MAX", 3);
+  const newDays = envInt2("PROJECT_ALIAS_NEW_TAG_DAYS", 14);
   const ageMs = Date.now() - tag.createdAt.getTime();
   return tag.memoryCount <= lowMax || ageMs <= newDays * 24 * 60 * 60 * 1e3;
 }
@@ -57763,7 +58091,7 @@ function messageMentionsTag(message, tag) {
   return compactName.length >= 3 && compactMessage.includes(compactName);
 }
 async function listCanonicalTags(userId) {
-  const maxTags = envInt("PROJECT_ALIAS_MAX_TAGS", 120);
+  const maxTags = envInt2("PROJECT_ALIAS_MAX_TAGS", 120);
   const result = await db.query(
     `SELECT pt.id,
             pt.name,
@@ -57865,7 +58193,7 @@ async function listRepresentativeMemories(userId, tagIds, perTag = 3) {
   return out;
 }
 async function addExplicitStatementCandidates(userId, tags, tagsById, pairs) {
-  const scanLimit = envInt("PROJECT_ALIAS_EXPLICIT_SCAN_LIMIT", 200);
+  const scanLimit = envInt2("PROJECT_ALIAS_EXPLICIT_SCAN_LIMIT", 200);
   const clauses = EXPLICIT_PATTERNS.map((_, i) => `message ILIKE $${i + 2}`).join(" OR ");
   const limitParam = EXPLICIT_PATTERNS.length + 2;
   const result = await db.query(
@@ -57950,10 +58278,10 @@ function addNameAndDtagCandidates(tags, tagsById, pairs) {
   }
 }
 async function addVectorCandidates(userId, tags, tagsById, pairs) {
-  const anchorLimit = envInt("PROJECT_ALIAS_VECTOR_ANCHOR_LIMIT", 12);
-  const representativeLimit = envInt("PROJECT_ALIAS_VECTOR_REPRESENTATIVE_LIMIT", 5);
-  const perMemoryLimit = envInt("PROJECT_ALIAS_VECTOR_PER_MEMORY_LIMIT", 8);
-  const perTagLimit = envInt("PROJECT_ALIAS_VECTOR_TARGET_LIMIT", 3);
+  const anchorLimit = envInt2("PROJECT_ALIAS_VECTOR_ANCHOR_LIMIT", 12);
+  const representativeLimit = envInt2("PROJECT_ALIAS_VECTOR_REPRESENTATIVE_LIMIT", 5);
+  const perMemoryLimit = envInt2("PROJECT_ALIAS_VECTOR_PER_MEMORY_LIMIT", 8);
+  const perTagLimit = envInt2("PROJECT_ALIAS_VECTOR_TARGET_LIMIT", 3);
   const maxDistance = envFloat("PROJECT_ALIAS_VECTOR_MAX_DISTANCE", 0.28);
   const anchors = tags.slice().sort((a, b) => {
     const aLow = isNewOrLowFrequency(a) ? 1 : 0;
@@ -58025,7 +58353,7 @@ async function addVectorCandidates(userId, tags, tagsById, pairs) {
     }
   }
 }
-async function buildCandidatePairs(userId, tags, limit2) {
+async function buildCandidatePairs(userId, tags, limit2, exclude = () => false) {
   const tagsById = new Map(tags.map((tag) => [tag.id, tag]));
   const pairs = /* @__PURE__ */ new Map();
   await addExplicitStatementCandidates(userId, tags, tagsById, pairs);
@@ -58040,7 +58368,7 @@ async function buildCandidatePairs(userId, tags, limit2) {
       pair.signals.candidate_sources = Array.from(pair.sources);
     }
   }
-  return Array.from(pairs.values()).sort((a, b) => {
+  return Array.from(pairs.values()).filter((pair) => !exclude(pair)).sort((a, b) => {
     const aExplicit = a.sources.has("explicit_user_statement") ? 1 : 0;
     const bExplicit = b.sources.has("explicit_user_statement") ? 1 : 0;
     if (aExplicit !== bExplicit) return bExplicit - aExplicit;
@@ -58109,7 +58437,7 @@ async function judgePair(pair, tagsById, memoriesByTag) {
   const allowedIds = collectAllowedMemoryIds(pair, sourceMemories, targetMemories);
   const promptSignals = { ...pair.signals };
   delete promptSignals.explicit_statement_previews;
-  const explicitPromptCap = envInt("PROJECT_ALIAS_EXPLICIT_PROMPT_CAP", 5);
+  const explicitPromptCap = envInt2("PROJECT_ALIAS_EXPLICIT_PROMPT_CAP", 5);
   const userPrompt = JSON.stringify(
     {
       task: "Judge whether Tag A and Tag B are the same project identity.",
@@ -58129,7 +58457,7 @@ async function judgePair(pair, tagsById, memoriesByTag) {
     system: JUDGE_SYSTEM_PROMPT,
     user: userPrompt,
     ...spec.provider === "local" ? { jsonSchema: JUDGE_SCHEMA, enableThinking: false } : { responseFormat: "json" },
-    maxTokens: envInt("PROJECT_ALIAS_JUDGE_MAX_TOKENS", 8192)
+    maxTokens: envInt2("PROJECT_ALIAS_JUDGE_MAX_TOKENS", 8192)
   });
   if (!raw) throw new Error("project_alias_judge returned empty content");
   return normalizeJudgment(raw, allowedIds);
@@ -58146,7 +58474,7 @@ async function areCanonicalRoots(tagIds) {
   return result.rows.every((row) => row.alias_of === null);
 }
 async function hasRecentRejectedPair(userId, sourceId, targetId) {
-  const rejectWindowDays = envInt("PROJECT_ALIAS_REJECT_WINDOW_DAYS", 30);
+  const rejectWindowDays = envInt2("PROJECT_ALIAS_REJECT_WINDOW_DAYS", 30);
   const result = await db.query(
     `SELECT 1
        FROM project_tag_alias_suggestions
@@ -58170,10 +58498,8 @@ async function computeAutoApplyEligible(userId, sourceId, targetId, pair, judgme
   if (await hasRecentRejectedPair(userId, sourceId, targetId)) return false;
   return true;
 }
-async function upsertSuggestion(userId, sourceId, targetId, pair, judgment, autoApplyEligible) {
-  const spec = ROLE_REGISTRY.project_alias_judge;
-  const candidateSources = Array.from(pair.sources);
-  const signals = {
+function aliasSignals(pair, judgment, sourceId, targetId) {
+  return {
     ...pair.signals,
     llm: {
       relation: judgment.relation,
@@ -58184,6 +58510,11 @@ async function upsertSuggestion(userId, sourceId, targetId, pair, judgment, auto
       direction_reversed_from_candidate: sourceId !== pair.sourceId || targetId !== pair.targetId
     }
   };
+}
+async function upsertSuggestion(userId, sourceId, targetId, pair, judgment, autoApplyEligible) {
+  const spec = ROLE_REGISTRY.project_alias_judge;
+  const candidateSources = Array.from(pair.sources);
+  const signals = aliasSignals(pair, judgment, sourceId, targetId);
   const result = await db.query(
     `INSERT INTO project_tag_alias_suggestions (
        user_id,
@@ -58245,12 +58576,103 @@ async function upsertSuggestion(userId, sourceId, targetId, pair, judgment, auto
   );
   return Number(result.rows[0].id);
 }
+async function loadPairHistory(userId, onlyPair) {
+  const result = await db.query(
+    `SELECT id, source_root, target_root, status, decided_by, decided, created_at, manual
+       FROM (SELECT id,
+                    canonical_project_tag_id(source_tag_id) AS source_root,
+                    canonical_project_tag_id(target_tag_id) AS target_root,
+                    status,
+                    decided_by,
+                    COALESCE(decided_at, updated_at, created_at) AS decided,
+                    created_at,
+                    'manual_set_alias' = ANY(candidate_sources) AS manual
+               FROM project_tag_alias_suggestions
+              WHERE user_id = $1) h
+      WHERE $2::bigint IS NULL
+         OR (LEAST(source_root, target_root) = LEAST($2::bigint, $3::bigint)
+             AND GREATEST(source_root, target_root) = GREATEST($2::bigint, $3::bigint))`,
+    [userId, onlyPair?.[0] ?? null, onlyPair?.[1] ?? null]
+  );
+  return groupPairHistory(
+    result.rows.filter((row) => row.source_root !== null && row.target_root !== null).map((row) => ({
+      id: Number(row.id),
+      sourceId: Number(row.source_root),
+      targetId: Number(row.target_root),
+      status: String(row.status),
+      decidedBy: row.decided_by === null ? null : String(row.decided_by),
+      decidedAt: toDate(row.decided),
+      createdAt: toDate(row.created_at),
+      manual: row.manual === true
+    }))
+  );
+}
+async function sweepRepeatedRejections(history) {
+  let swept = 0;
+  let errors = 0;
+  for (const rows of history.values()) {
+    for (const { pendingId, rejectedId } of repeatsToSweep(rows)) {
+      try {
+        const result = await db.query(
+          `UPDATE project_tag_alias_suggestions
+              SET status = 'rejected',
+                  decided_by = 'system',
+                  decision_reason = $2,
+                  signals = signals || jsonb_build_object('repeat_of_suggestion_id', $3::bigint),
+                  decided_at = NOW(),
+                  updated_at = NOW()
+            WHERE id = $1
+              AND status = 'pending'
+              AND NOT ('manual_set_alias' = ANY(candidate_sources))`,
+          [pendingId, `repeat of suggestion #${rejectedId} rejected by the user`, rejectedId]
+        );
+        swept += result.rowCount ?? 0;
+      } catch (err3) {
+        errors++;
+        console.error(`[ProjectAliasPromoter] sweep of suggestion ${pendingId} failed:`, err3);
+      }
+    }
+  }
+  return { swept, errors };
+}
+async function recordRepeatOfRejected(userId, sourceId, targetId, pair, judgment, rejectedId) {
+  const spec = ROLE_REGISTRY.project_alias_judge;
+  await db.query(
+    `INSERT INTO project_tag_alias_suggestions (
+       user_id, source_tag_id, target_tag_id, relation, status, confidence,
+       candidate_sources, evidence_memory_ids, conflict_memory_ids, signals,
+       model_provider, model_name, rationale, auto_apply_eligible,
+       decided_by, decision_reason, decided_at
+     )
+     VALUES (
+       $1, $2, $3, $4, 'rejected', $5,
+       $6::text[], $7::bigint[], $8::bigint[], $9::jsonb,
+       $10, $11, $12, FALSE,
+       'system', $13, NOW()
+     )`,
+    [
+      userId,
+      sourceId,
+      targetId,
+      judgment.relation,
+      Number(judgment.confidence.toFixed(4)),
+      Array.from(pair.sources),
+      judgment.evidence_memory_ids,
+      judgment.conflict_memory_ids,
+      JSON.stringify({ ...aliasSignals(pair, judgment, sourceId, targetId), repeat_of_suggestion_id: rejectedId }),
+      spec.provider,
+      spec.model_name,
+      truncate(judgment.rationale, 4e3),
+      `repeat of suggestion #${rejectedId} rejected by the user`
+    ]
+  );
+}
 function qualifiesForPending(judgment, minConfidence) {
   return QUALIFYING_RELATIONS.has(judgment.relation) && judgment.same_project && judgment.confidence >= minConfidence;
 }
 async function runProjectAliasPromoter(opts = {}) {
   const userId = opts.userId ?? await getDefaultUserId();
-  const candidateLimit = opts.limit ?? envInt("PROJECT_ALIAS_CANDIDATE_LIMIT", 12);
+  const candidateLimit = opts.limit ?? envInt2("PROJECT_ALIAS_CANDIDATE_LIMIT", 12);
   const pendingMin = envFloat("PROJECT_ALIAS_PENDING_MIN", 0.85);
   const summary = {
     userId,
@@ -58259,12 +58681,23 @@ async function runProjectAliasPromoter(opts = {}) {
     inserted: 0,
     autoApplied: 0,
     skipped: 0,
-    errors: 0
+    errors: 0,
+    blockedBeforeJudge: 0,
+    blockedAfterJudge: 0,
+    swept: 0
   };
+  const history = await loadPairHistory(userId);
+  const sweep = await sweepRepeatedRejections(history);
+  summary.swept = sweep.swept;
+  summary.errors += sweep.errors;
   const tags = await listCanonicalTags(userId);
   if (tags.length < 2) return summary;
   const tagsById = new Map(tags.map((tag) => [tag.id, tag]));
-  const pairs = await buildCandidatePairs(userId, tags, candidateLimit);
+  const pairs = await buildCandidatePairs(userId, tags, candidateLimit, (pair) => {
+    const skip = skipBeforeJudge(history.get(pairKey(pair.sourceId, pair.targetId)));
+    if (skip) summary.blockedBeforeJudge++;
+    return skip;
+  });
   summary.candidates = pairs.length;
   if (pairs.length === 0) return summary;
   const tagIdsForPrompt = uniqueSortedNumbers(
@@ -58289,6 +58722,14 @@ async function runProjectAliasPromoter(opts = {}) {
         summary.skipped++;
         continue;
       }
+      const key = pairKey(sourceId, targetId);
+      const live = await loadPairHistory(userId, [sourceId, targetId]);
+      const rejectedId = userRejectedDirection(history.get(key), sourceId, targetId) ?? userRejectedDirection(live.get(key), sourceId, targetId);
+      if (rejectedId !== null) {
+        await recordRepeatOfRejected(userId, sourceId, targetId, pair, judgment, rejectedId);
+        summary.blockedAfterJudge++;
+        continue;
+      }
       const autoApplyEligible = await computeAutoApplyEligible(
         userId,
         sourceId,
@@ -58323,7 +58764,7 @@ async function maybeRunProjectAliasPromoter() {
   if (process.env.PROJECT_ALIAS_PROMOTER_ENABLED !== "true") return;
   if (projectAliasPromoterRunning) return;
   projectAliasPromoterRunning = true;
-  const intervalHours = envInt(
+  const intervalHours = envInt2(
     "PROJECT_ALIAS_PROMOTER_INTERVAL_HOURS",
     PROJECT_ALIAS_PROMOTER_DEFAULT_INTERVAL_HOURS
   );
@@ -58346,9 +58787,9 @@ async function maybeRunProjectAliasPromoter() {
       [userId]
     );
     const summary = await runProjectAliasPromoter({ userId });
-    if (summary.candidates > 0 || summary.inserted > 0 || summary.errors > 0) {
+    if (summary.candidates > 0 || summary.inserted > 0 || summary.errors > 0 || summary.swept > 0 || summary.blockedBeforeJudge > 0) {
       console.error(
-        `\u{1F501} [ProjectAliasPromoter] done \u2014 candidates=${summary.candidates}, judged=${summary.judged}, inserted=${summary.inserted}, autoApplied=${summary.autoApplied}, skipped=${summary.skipped}, errors=${summary.errors}`
+        `\u{1F501} [ProjectAliasPromoter] done \u2014 candidates=${summary.candidates}, judged=${summary.judged}, inserted=${summary.inserted}, autoApplied=${summary.autoApplied}, skipped=${summary.skipped}, errors=${summary.errors}, blockedBeforeJudge=${summary.blockedBeforeJudge}, blockedAfterJudge=${summary.blockedAfterJudge}, swept=${summary.swept}`
       );
     }
   } catch (err3) {
@@ -58444,13 +58885,13 @@ async function applyAliasSuggestion(suggestionId, opts = {}) {
     }
     if (!Number.isInteger(targetRoot) || targetRoot === sourceId) {
       const msg = "alias would point source to itself";
-      await markSuggestionTerminal(client2, suggestionId, "rejected", decidedBy, msg);
+      await markSuggestionTerminal(client2, suggestionId, "rejected", "system", msg);
       await client2.query("COMMIT");
       return { suggestionId, applied: false, status: "rejected", reason: msg };
     }
     if (await targetChainContainsSource(client2, sourceId, targetId)) {
       const msg = "alias would create a project_tag alias cycle";
-      await markSuggestionTerminal(client2, suggestionId, "rejected", decidedBy, msg);
+      await markSuggestionTerminal(client2, suggestionId, "rejected", "system", msg);
       await client2.query("COMMIT");
       return { suggestionId, applied: false, status: "rejected", reason: msg };
     }
@@ -58657,6 +59098,76 @@ async function rejectAlias(userId, suggestionId, reason) {
     decided_at: row.decided_at
   });
 }
+async function listNewTags(userId, status, limit2) {
+  const result = await db.query(
+    `SELECT id, name, uses, recommendation, rationale, created_at, last_seen_at,
+            decided_by, decision_reason, decided_at
+       FROM project_tag_new_suggestions
+      WHERE user_id = $1
+        AND status = $2
+      ORDER BY created_at DESC
+      LIMIT $3`,
+    [userId, status, limit2]
+  );
+  const suggestions = result.rows.map((row) => ({
+    suggestion_id: Number(row.id),
+    name: String(row.name),
+    uses: Number(row.uses),
+    recommendation: row.recommendation ?? null,
+    rationale: String(row.rationale ?? ""),
+    created_at: row.created_at,
+    last_seen_at: row.last_seen_at,
+    decided_by: row.decided_by ?? null,
+    decision_reason: row.decision_reason ?? null,
+    decided_at: row.decided_at ?? null
+  }));
+  return ok2({ action: "list_new_tags", status, limit: limit2, count: suggestions.length, suggestions });
+}
+function decisionResult(action, result) {
+  if (result.error) return toolError(result.error, { action, ...result });
+  return ok2({ action, ...result });
+}
+async function applyRecommendations(userId, ids, reason) {
+  const rows = await db.query(
+    `SELECT id, name, status, recommendation
+       FROM project_tag_new_suggestions
+      WHERE user_id = $1
+        AND id = ANY($2::bigint[])`,
+    [userId, ids]
+  );
+  const names = new Map(rows.rows.map((r) => [Number(r.id), String(r.name)]));
+  const plan = planApplyRecommendations(
+    ids,
+    rows.rows.map((r) => ({
+      id: Number(r.id),
+      status: String(r.status),
+      recommendation: parseRecommendation(r.recommendation)
+    }))
+  );
+  const why = reason ? `apply_recommendations: ${reason}` : "apply_recommendations";
+  const confirmed = [];
+  const rejected = [];
+  const failed = [];
+  const decide = async (id, fn, done) => {
+    try {
+      const r = await fn(userId, id, { decidedBy: "user", reason: why });
+      (r.error ? failed : done).push(r);
+    } catch (err3) {
+      failed.push({ suggestion_id: id, name: names.get(id) ?? "", status: "error", error: errorDetail(err3) });
+    }
+  };
+  for (const id of plan.confirm) await decide(id, confirmNewTagSuggestion, confirmed);
+  for (const id of plan.reject) await decide(id, rejectNewTagSuggestion, rejected);
+  const label = (id) => ({ suggestion_id: id, name: names.get(id) ?? null });
+  return ok2({
+    action: "apply_recommendations",
+    confirmed,
+    rejected,
+    kept_pending: plan.keep.map(label),
+    skipped_not_pending: plan.skipped.map(label),
+    failed
+  });
+}
 async function setAlias(userId, sourceTagName, targetTagName, reason) {
   const sourceName = normalizeTagName(sourceTagName);
   const targetName = normalizeTagName(targetTagName);
@@ -58777,25 +59288,36 @@ function registerManageProjectTags(server) {
   server.registerTool(
     "manage_project_tags",
     {
-      description: `Project tag alias suggestion management tool (Stage 2 / DEVLOG \xA719).
+      description: `Project tag suggestion management tool (Stage 2 / DEVLOG \xA719).
 
-Actions:
+Alias suggestions (two existing tags look like the same project):
   - list_suggestions: list alias suggestions by status for the default user.
   - confirm_alias: confirm a pending suggestion through applyAliasSuggestion().
   - reject_alias: reject a pending suggestion.
   - 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.`,
+  - 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):
+  - 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.
+  - apply_recommendations: when the user accepts the recommendations ("\uCD94\uCC9C\uB300\uB85C"), pass the suggestion_ids that were shown to them. project \u2192 confirmed, generic \u2192 rejected, unsure / no recommendation \u2192 left pending for the user to decide.`,
       inputSchema: {
         action: external_exports.enum([
           "list_suggestions",
           "confirm_alias",
           "reject_alias",
           "set_alias",
-          "unset_alias"
+          "unset_alias",
+          "list_new_tags",
+          "confirm_new_tag",
+          "reject_new_tag",
+          "apply_recommendations"
         ]).describe("\uC791\uC5C5 \uC885\uB958"),
-        status: statusSchema.optional().describe("list_suggestions status filter (default pending)"),
-        limit: external_exports.number().int().min(1).max(MAX_LIMIT).optional().describe(`list_suggestions limit (default ${DEFAULT_LIMIT2})`),
-        suggestion_id: external_exports.number().int().positive().optional().describe("confirm_alias/reject_alias \uB300\uC0C1 suggestion id"),
+        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})`),
+        suggestion_id: external_exports.number().int().positive().optional().describe("confirm_alias/reject_alias/confirm_new_tag/reject_new_tag \uB300\uC0C1 suggestion id"),
+        suggestion_ids: external_exports.array(external_exports.number().int().positive()).min(1).max(MAX_LIMIT).optional().describe("apply_recommendations: \uC0AC\uC6A9\uC790\uC5D0\uAC8C \uBCF4\uC5EC \uC900 \uC0C8 \uD0DC\uADF8 \uC81C\uC548 id \uBAA9\uB85D"),
         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"),
@@ -58830,6 +59352,22 @@ Actions:
         if (args.action === "unset_alias") {
           return unsetAlias(userId, args.tag);
         }
+        if (args.action === "list_new_tags") {
+          return listNewTags(userId, args.status ?? "pending", args.limit ?? DEFAULT_LIMIT2);
+        }
+        if (args.action === "confirm_new_tag" || args.action === "reject_new_tag") {
+          if (args.suggestion_id == null) {
+            return toolError(`suggestion_id is required for ${args.action}`);
+          }
+          const decide = args.action === "confirm_new_tag" ? confirmNewTagSuggestion : rejectNewTagSuggestion;
+          return decisionResult(args.action, await decide(userId, args.suggestion_id, { decidedBy: "user", reason: args.reason }));
+        }
+        if (args.action === "apply_recommendations") {
+          if (!args.suggestion_ids?.length) {
+            return toolError("suggestion_ids is required for apply_recommendations");
+          }
+          return applyRecommendations(userId, args.suggestion_ids, args.reason);
+        }
         return toolError("unsupported action", { action: args.action });
       } catch (err3) {
         return toolError("manage_project_tags failed", { detail: errorDetail(err3) });
@@ -58850,6 +59388,7 @@ var PREVIEW_COMPACT = 100;
 var PREVIEW_RECENT = 300;
 var ACTIVE_PTAG_LIMIT = 5;
 var PENDING_ALIAS_SUGGESTION_LIMIT = 2;
+var PENDING_NEW_TAG_LIMIT = 2;
 var PINNED_LIMIT = 10;
 var INJECT_PINNED_LIMIT = 5;
 var BRIEF_MAX_CHARS = Number(process.env.BRIEF_MAX_CHARS ?? 8e3);
@@ -58946,11 +59485,32 @@ async function collectBrief(opts = {}) {
       LIMIT $2`,
     [userId, PENDING_ALIAS_SUGGESTION_LIMIT]
   );
+  let newTags = [];
+  try {
+    const r = await db.query(
+      `SELECT id, name, uses, recommendation
+         FROM project_tag_new_suggestions
+        WHERE user_id = $1 AND status = 'pending'
+          AND recommendation IS DISTINCT FROM 'generic'
+        ORDER BY (recommendation = 'project') DESC NULLS LAST, uses DESC
+        LIMIT $2`,
+      [userId, PENDING_NEW_TAG_LIMIT]
+    );
+    newTags = r.rows;
+  } catch {
+    newTags = [];
+  }
   return {
     user_name: user.user_name,
     core_profile: user.core_profile,
     sub_profile: user.sub_profile,
     pinned_memories: pinnedMsgs.rows.map(rowToMsg),
+    pending_new_tags: newTags.map((r) => ({
+      id: Number(r.id),
+      name: String(r.name),
+      uses: Number(r.uses),
+      recommendation: r.recommendation ?? null
+    })),
     pending_alias_suggestions: aliasSugg.rows.map((r) => ({
       id: Number(r.id),
       source: String(r.source),
@@ -59012,11 +59572,14 @@ function formatBriefFull(brief) {
     }
     gLines.push("");
   }
-  if (brief.pending_alias_suggestions.length > 0) {
+  if (brief.pending_alias_suggestions.length > 0 || brief.pending_new_tags.length > 0) {
     gLines.push("## Project Tag Suggestions (\uC0AC\uC6A9\uC790 \uD655\uC778 \uD544\uC694)");
     for (const s of brief.pending_alias_suggestions) {
       gLines.push(`- [${s.id}] \`${s.source}\` \u2192 \`${s.target}\` \uAC19\uC740 \uD504\uB85C\uC81D\uD2B8\uB85C \uBCF4\uC784 (${s.relation}, conf ${s.confidence}). \uB9DE\uC73C\uBA74 \`manage_project_tags({action:"confirm_alias",suggestion_id:${s.id}})\`, \uC544\uB2C8\uBA74 \`reject_alias\`.`);
     }
+    for (const t of brief.pending_new_tags) {
+      gLines.push(`- [new ${t.id}] \`${t.name}\` \uC0C8 \uD504\uB85C\uC81D\uD2B8 \uD0DC\uADF8 \uD6C4\uBCF4 (${t.uses}\uD68C, \uCD94\uCC9C ${t.recommendation ?? "\uC5C6\uC74C"}). \uB9DE\uC73C\uBA74 \`manage_project_tags({action:"confirm_new_tag",suggestion_id:${t.id}})\`, \uC544\uB2C8\uBA74 \`reject_new_tag\`.`);
+    }
     gLines.push("");
   }
   const guaranteed = gLines.join("\n");
@@ -60665,155 +61228,6 @@ function registerTools(server) {
 init_db();
 init_buzz_envelope();
 
-// src/cold_path/dtag_promoter.ts
-init_db();
-init_users();
-function envInt2(name, fallback) {
-  const raw = process.env[name];
-  if (!raw) return fallback;
-  const n = Number(raw);
-  return Number.isFinite(n) && n >= 1 ? n : fallback;
-}
-var CLUSTER_SYSTEM = `You are a keyword clustering assistant for a personal memory system.
-
-Given a list of d_tags (short hyphenated keywords) with their occurrence counts,
-group semantically similar tags that refer to the same project or topic.
-
-OUTPUT strict JSON object (NOT a bare array):
-{ "clusters": [
-  { "canonical": "<best-slug>", "members": ["<tag1>", "<tag2>", ...] }
-] }
-
-Rules:
-- canonical must be one of the input tags (pick the most descriptive one) or a clean slug if none fit
-- canonical must be lowercase, hyphenated (e.g. "yt-signal-finder")
-- Only group tags that clearly refer to the same project/topic
-- Tags with no similar counterparts become their own single-member cluster
-- Do NOT merge unrelated topics just because they share one word`;
-var CLUSTER_SCHEMA = {
-  type: "object",
-  properties: {
-    clusters: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          canonical: { type: "string" },
-          members: { type: "array", items: { type: "string" } }
-        },
-        required: ["canonical", "members"],
-        additionalProperties: false
-      }
-    }
-  },
-  required: ["clusters"],
-  additionalProperties: false
-};
-async function clusterDTags(tags) {
-  if (tags.length === 0) return [];
-  const tagList = tags.map((t) => `${t.tag} (${t.cnt}x)`).join(", ");
-  const userPrompt = `Cluster these d_tags by project/topic:
-${tagList}`;
-  let raw;
-  try {
-    raw = await callRole("clusterer", {
-      system: CLUSTER_SYSTEM,
-      user: userPrompt,
-      jsonSchema: CLUSTER_SCHEMA,
-      enableThinking: false,
-      maxTokens: 4096
-      // was 512 — 50개 태그 클러스터링 출력이 잘려 invalid JSON 폴백됨 (ctx 8192 내 여유)
-    });
-  } catch (err3) {
-    console.error("\u26A0\uFE0F [DTagPromoter] clusterer call failed, falling back to no clustering:", err3);
-    return tags.map((t) => ({ canonical: t.tag, members: [t.tag], total: t.cnt }));
-  }
-  let parsed;
-  try {
-    const obj = JSON.parse(raw);
-    parsed = obj?.clusters;
-    if (!Array.isArray(parsed)) throw new Error("no clusters array");
-  } catch {
-    console.error("\u26A0\uFE0F [DTagPromoter] clusterer returned invalid JSON, falling back:", raw.slice(0, 200));
-    return tags.map((t) => ({ canonical: t.tag, members: [t.tag], total: t.cnt }));
-  }
-  const freqMap = new Map(tags.map((t) => [t.tag, t.cnt]));
-  return parsed.map((c) => {
-    const canonical = String(c.canonical || "").toLowerCase().trim().replace(/\s+/g, "-");
-    const members = Array.isArray(c.members) ? c.members.map((m) => String(m).toLowerCase().trim()).filter(Boolean) : [canonical];
-    const total = members.reduce((sum, m) => sum + (freqMap.get(m) ?? 0), 0);
-    return { canonical, members, total };
-  });
-}
-async function runDtagPromotion() {
-  const minCount = envInt2("DTAG_PROMOTE_MIN_COUNT", 10);
-  const windowDays = envInt2("DTAG_PROMOTE_WINDOW_DAYS", 30);
-  const userId = await getDefaultUserId();
-  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
-      LIMIT 50`,
-    [userId, String(windowDays)]
-  );
-  if (freqResult.rows.length === 0) return { promoted: [], retrotagged: 0 };
-  const tags = freqResult.rows.map((r) => ({
-    tag: String(r.tag).toLowerCase().trim(),
-    cnt: Number(r.cnt)
-  })).filter((t) => t.tag.length > 0);
-  const clusters = await clusterDTags(tags);
-  const toPromote = clusters.filter((c) => c.total >= minCount);
-  if (toPromote.length === 0) return { promoted: [], retrotagged: 0 };
-  const summary = { promoted: [], retrotagged: 0 };
-  for (const cluster of toPromote) {
-    if (!cluster.canonical) continue;
-    const upsert = await db.query(
-      `INSERT INTO project_tags (name)
-         VALUES ($1)
-         ON CONFLICT (name) DO NOTHING
-         RETURNING id`,
-      [cluster.canonical]
-    );
-    let pTagId;
-    if (upsert.rows.length > 0) {
-      pTagId = Number(upsert.rows[0].id);
-      summary.promoted.push(cluster.canonical);
-      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] promoted "${cluster.canonical}" (total=${cluster.total}, members=${cluster.members.join(", ")})`);
-      invalidateCandidateCache();
-    } else {
-      const existing = await db.query(
-        `SELECT id FROM project_tags WHERE name = $1 LIMIT 1`,
-        [cluster.canonical]
-      );
-      if (existing.rows.length === 0) continue;
-      pTagId = Number(existing.rows[0].id);
-    }
-    for (const memberTag of cluster.members) {
-      const updated = await db.query(
-        `UPDATE memory
-            SET p_tag_id = $1, updated_at = NOW()
-          WHERE user_id = $2
-            AND tag_processed = TRUE
-            AND p_tag_id IS NULL
-            AND $3 = ANY(d_tag)
-         RETURNING id`,
-        [pTagId, userId, memberTag]
-      );
-      summary.retrotagged += updated.rows.length;
-    }
-    if (summary.retrotagged > 0) {
-      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] retrotagged ${summary.retrotagged} rows with "${cluster.canonical}"`);
-    }
-  }
-  return summary;
-}
-
 // src/librarian.ts
 init_db();
 init_users();
@@ -61326,8 +61740,8 @@ async function maybeRunPromotion() {
   if (tickCount % DTAG_PROMOTE_EVERY_N_TICKS !== 0) return;
   try {
     const result = await runDtagPromotion();
-    if (result.promoted.length > 0 || result.retrotagged > 0) {
-      console.error(`\u{1F3F7}\uFE0F [DTagPromoter] promoted=${result.promoted.length} tags, retrotagged=${result.retrotagged} rows`);
+    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`);
     }
   } catch (err3) {
     console.error("\u26A0\uFE0F [DTagPromoter] promotion error (non-blocking):", err3);