recallnest 1.4.1

package/src/conflict-schema.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+
+import { MemoryCategorySchema, MemoryImportanceSchema, MemoryScopeSchema, MemoryTextSchema, StoreMemorySourceSchema, DurableMemoryCategorySchema, CanonicalKeySchema } from "./memory-schema.js";
+import { MEMORY_AUTHORITIES, MEMORY_CONFLICT_POLICIES, MEMORY_LAYERS } from "./memory-boundaries.js";
+import { identifierSchema, optionalBoundedStringSchema } from "./schema-utils.js";
+
+const BoundaryMetadataSchema = z.object({
+  layer: z.enum(MEMORY_LAYERS),
+  authority: z.enum(MEMORY_AUTHORITIES),
+  conflictPolicy: z.enum(MEMORY_CONFLICT_POLICIES),
+  originalCategory: DurableMemoryCategorySchema.optional(),
+  downgradedFrom: DurableMemoryCategorySchema.optional(),
+  note: optionalBoundedStringSchema(240),
+});
+
+export const ConflictReasonSchema = z.enum([
+  "promotion_conflicts_with_existing_durable",
+  "canonical_key_conflicts_with_existing_durable",
+]);
+
+export const ConflictStatusSchema = z.enum([
+  "open",
+  "accepted-incoming",
+  "kept-existing",
+  "merged",
+]);
+
+export const ConflictExistingMemorySchema = z.object({
+  memoryId: identifierSchema("memoryId", 128),
+  text: MemoryTextSchema,
+  category: MemoryCategorySchema,
+  scope: identifierSchema("scope", 160),
+  importance: MemoryImportanceSchema,
+  metadata: z.string().min(1).max(8000),
+  boundary: BoundaryMetadataSchema.nullable().optional(),
+  canonicalKey: CanonicalKeySchema,
+});
+
+export const ConflictIncomingMemorySchema = z.object({
+  text: MemoryTextSchema,
+  category: DurableMemoryCategorySchema,
+  scope: identifierSchema("scope", 160),
+  importance: MemoryImportanceSchema,
+  metadata: z.string().min(1).max(8000),
+  source: StoreMemorySourceSchema,
+  sourceMemoryId: identifierSchema("sourceMemoryId", 128).optional(),
+  sourceCategory: MemoryCategorySchema.optional(),
+  sourceBoundary: BoundaryMetadataSchema.nullable().optional(),
+});
+
+export const ConflictCandidateInputSchema = z.object({
+  canonicalKey: z.string().min(1).max(120),
+  category: DurableMemoryCategorySchema,
+  fingerprint: z.string().min(1).max(240),
+  reason: ConflictReasonSchema,
+  existing: ConflictExistingMemorySchema,
+  incoming: ConflictIncomingMemorySchema,
+  createdAt: z.string().datetime().default(() => new Date().toISOString()),
+  updatedAt: z.string().datetime().default(() => new Date().toISOString()),
+});
+
+export const ConflictCandidateRecordSchema = ConflictCandidateInputSchema.extend({
+  conflictId: identifierSchema("conflictId", 128),
+  status: ConflictStatusSchema.default("open"),
+  reopenCount: z.number().int().min(0).default(0),
+  escalationCount: z.number().int().min(0).default(0),
+  lastReopenedAt: z.string().datetime().optional(),
+  lastEscalatedAt: z.string().datetime().optional(),
+  lastEscalationAttention: z.enum(["stale", "escalated"]).optional(),
+  resolvedAt: z.string().datetime().optional(),
+  resolutionNotes: optionalBoundedStringSchema(320),
+});
+
+export const ResolveConflictInputSchema = z.object({
+  conflictId: identifierSchema("conflictId", 128),
+  resolution: z.enum(["accept_incoming", "keep_existing", "merge"]),
+  mergedText: MemoryTextSchema.optional(),
+  notes: optionalBoundedStringSchema(320),
+});
+
+export const ConflictResolutionResultSchema = z.object({
+  conflictId: identifierSchema("conflictId", 128),
+  status: ConflictStatusSchema,
+  updatedAt: z.string().datetime(),
+  resolvedAt: z.string().datetime(),
+  updatedMemoryId: identifierSchema("updatedMemoryId", 128).optional(),
+});
+
+export const EscalateConflictsInputSchema = z.object({
+  attention: z.enum(["stale", "escalated"]).optional(),
+  canonicalKey: CanonicalKeySchema.optional(),
+  limit: z.number().int().min(1).max(500).default(100),
+  top: z.number().int().min(1).max(20).default(10),
+  apply: z.boolean().default(false),
+  notes: optionalBoundedStringSchema(320),
+});
+
+export const ConflictEscalationResultItemSchema = z.object({
+  conflictId: identifierSchema("conflictId", 128),
+  canonicalKey: CanonicalKeySchema,
+  attention: z.enum(["stale", "escalated"]),
+  openAgeDays: z.number().int().min(0),
+  reopenCount: z.number().int().min(0),
+  escalationCount: z.number().int().min(0),
+  suggestedResolution: z.enum(["keep_existing", "accept_incoming", "manual_review"]),
+  confidence: z.enum(["low", "medium", "high"]),
+  action: z.enum(["pending", "escalated", "already-escalated"]),
+  clusterKey: z.string().min(1).max(240),
+});
+
+export const EscalateConflictsResultSchema = z.object({
+  apply: z.boolean(),
+  scanned: z.number().int().min(0),
+  eligible: z.number().int().min(0),
+  escalated: z.number().int().min(0),
+  skipped: z.number().int().min(0),
+  items: z.array(ConflictEscalationResultItemSchema),
+});
+
+export type ConflictReason = z.infer<typeof ConflictReasonSchema>;
+export type ConflictStatus = z.infer<typeof ConflictStatusSchema>;
+export type ConflictExistingMemory = z.infer<typeof ConflictExistingMemorySchema>;
+export type ConflictIncomingMemory = z.infer<typeof ConflictIncomingMemorySchema>;
+export type ConflictCandidateInput = z.infer<typeof ConflictCandidateInputSchema>;
+export type ConflictCandidateRecord = z.infer<typeof ConflictCandidateRecordSchema>;
+export type ResolveConflictInput = z.infer<typeof ResolveConflictInputSchema>;
+export type ConflictResolutionResult = z.infer<typeof ConflictResolutionResultSchema>;
+export type EscalateConflictsInput = z.infer<typeof EscalateConflictsInputSchema>;
+export type ConflictEscalationResultItem = z.infer<typeof ConflictEscalationResultItemSchema>;
+export type EscalateConflictsResult = z.infer<typeof EscalateConflictsResultSchema>;

package/src/conflict-store.ts

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import type { ConflictCandidateRecord, ConflictStatus } from "./conflict-schema.js";
+import { ConflictCandidateRecordSchema } from "./conflict-schema.js";
+
+export interface ConflictCandidateQuery {
+  status?: ConflictStatus;
+  canonicalKey?: string;
+  limit?: number;
+}
+
+function ensureDir(dir: string): string {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function sortNewestFirst(records: ConflictCandidateRecord[]): ConflictCandidateRecord[] {
+  return [...records].sort((a, b) => {
+    const timeDiff = Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+    if (timeDiff !== 0) return timeDiff;
+    return b.conflictId.localeCompare(a.conflictId);
+  });
+}
+
+export class ConflictCandidateStore {
+  constructor(private readonly dir = resolve(import.meta.dir, "../data/conflict-candidates")) {}
+
+  get dataDir(): string {
+    return ensureDir(this.dir);
+  }
+
+  async save(record: ConflictCandidateRecord): Promise<ConflictCandidateRecord> {
+    const parsed = ConflictCandidateRecordSchema.parse(record);
+    const timestampToken = parsed.createdAt.replace(/[:.]/g, "-");
+    const path = join(this.dataDir, `${timestampToken}-${parsed.conflictId}.json`);
+    writeFileSync(path, JSON.stringify(parsed, null, 2) + "\n");
+    return parsed;
+  }
+
+  async replace(record: ConflictCandidateRecord): Promise<ConflictCandidateRecord> {
+    const parsed = ConflictCandidateRecordSchema.parse(record);
+    const existingPath = this.findPathById(parsed.conflictId);
+    const timestampToken = parsed.createdAt.replace(/[:.]/g, "-");
+    const path = existingPath || join(this.dataDir, `${timestampToken}-${parsed.conflictId}.json`);
+    writeFileSync(path, JSON.stringify(parsed, null, 2) + "\n");
+    return parsed;
+  }
+
+  async listRecent(query: ConflictCandidateQuery = {}): Promise<ConflictCandidateRecord[]> {
+    const { status, canonicalKey, limit = 20 } = query;
+    const files = readdirSync(this.dataDir)
+      .filter((name) => name.endsWith(".json"))
+      .map((name) => join(this.dataDir, name));
+
+    const items: ConflictCandidateRecord[] = [];
+    for (const path of files) {
+      try {
+        const parsed = ConflictCandidateRecordSchema.parse(
+          JSON.parse(readFileSync(path, "utf-8")),
+        );
+        if (status && parsed.status !== status) continue;
+        if (canonicalKey && parsed.canonicalKey !== canonicalKey) continue;
+        items.push(parsed);
+      } catch {
+        // Skip corrupt conflict files.
+      }
+    }
+
+    return sortNewestFirst(items).slice(0, limit);
+  }
+
+  async getById(conflictId: string): Promise<ConflictCandidateRecord | null> {
+    const path = this.findPathById(conflictId);
+    if (!path) return null;
+    try {
+      return ConflictCandidateRecordSchema.parse(
+        JSON.parse(readFileSync(path, "utf-8")),
+      );
+    } catch {
+      return null;
+    }
+  }
+
+  async getOpenByFingerprint(fingerprint: string): Promise<ConflictCandidateRecord | null> {
+    const items = await this.listRecent({ status: "open", limit: 200 });
+    return items.find((item) => item.fingerprint === fingerprint) || null;
+  }
+
+  async getLatestByFingerprint(fingerprint: string): Promise<ConflictCandidateRecord | null> {
+    const items = await this.listRecent({ limit: 200 });
+    return items.find((item) => item.fingerprint === fingerprint) || null;
+  }
+
+  private findPathById(conflictId: string): string | null {
+    const exact = readdirSync(this.dataDir)
+      .filter((name) => name.endsWith(`-${conflictId}.json`))
+      .map((name) => join(this.dataDir, name));
+    if (exact.length > 0) {
+      return exact[0] || null;
+    }
+
+    const files = readdirSync(this.dataDir)
+      .filter((name) => name.endsWith(".json"))
+      .map((name) => join(this.dataDir, name));
+
+    const matches: string[] = [];
+    for (const path of files) {
+      try {
+        const parsed = ConflictCandidateRecordSchema.parse(
+          JSON.parse(readFileSync(path, "utf-8")),
+        );
+        if (parsed.conflictId.startsWith(conflictId)) {
+          matches.push(path);
+        }
+      } catch {
+        // Skip corrupt conflict files.
+      }
+    }
+
+    if (matches.length > 1) {
+      throw new Error(`Ambiguous conflict prefix "${conflictId}" matches ${matches.length} conflicts. Use a longer prefix or full ID.`);
+    }
+
+    return matches[0] || null;
+  }
+}

package/src/consolidation-engine.ts

@@ -0,0 +1,256 @@
+/**
+ * Semantic Consolidation Engine
+ *
+ * Borrowed from UltraMemory's consolidation-engine.ts, adapted for RecallNest:
+ * - Uses RecallNest's store.vectorSearch() + store.update() (no patchMetadata)
+ * - Integrates with RecallNest's existing conflict-engine for conflict creation
+ * - Uses RecallNest's metadata structure (boundary.layer, canonicalKey, etc.)
+ *
+ * Algorithm:
+ * 1. List entries in scope, filter active ones, group by category
+ * 2. For each category: cluster entries by vector similarity (>= clusterThreshold)
+ * 3. Within each cluster:
+ *    - Merge near-duplicates (>= mergeThreshold) → archive weaker entry
+ *    - Link related entries (cluster but below merge) → add clustered_with
+ *    - Detect contradictions via heuristic
+ *
+ * LLM-free — deterministic clustering and merge only.
+ */
+
+import type { MemoryEntry, MemorySearchResult, MemoryStore } from "./store.js";
+import { createVersionGroup } from "./version-manager.js";
+
+// ---------------------------------------------------------------------------
+// Config & Types
+// ---------------------------------------------------------------------------
+
+export interface ConsolidationConfig {
+  /** Minimum cosine similarity to form a cluster (default 0.82) */
+  clusterThreshold: number;
+  /** Minimum cosine similarity to merge (archive the weaker entry) (default 0.92) */
+  mergeThreshold: number;
+  /** Maximum entries to scan per consolidation run (default 500) */
+  maxEntriesPerRun: number;
+}
+
+export const DEFAULT_CONSOLIDATION_CONFIG: ConsolidationConfig = {
+  clusterThreshold: 0.82,
+  mergeThreshold: 0.92,
+  maxEntriesPerRun: 500,
+};
+
+export interface ConflictEvent {
+  memoryA: string;
+  memoryB: string;
+  type: "heuristic_contradiction";
+}
+
+export interface ConsolidationResult {
+  originalCount: number;
+  clustersFound: number;
+  mergedCount: number;
+  relationsAdded: number;
+  conflictsDetected: ConflictEvent[];
+  scope: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseMetadata(entry: MemoryEntry): Record<string, unknown> {
+  if (!entry.metadata) return {};
+  try { return JSON.parse(entry.metadata); } catch { return {}; }
+}
+
+function isActive(entry: MemoryEntry): boolean {
+  const meta = parseMetadata(entry);
+  return meta.state !== "archived" && meta.state !== "superseded";
+}
+
+function canonicalScore(entry: MemoryEntry): number {
+  const meta = parseMetadata(entry);
+  const accessCount = typeof meta.accessCount === "number" ? meta.accessCount : 0;
+  return entry.importance * (1 + Math.log(accessCount + 1));
+}
+
+/** Simple heuristic contradiction: negation pattern check between two texts. */
+function detectHeuristicContradiction(textA: string, textB: string): boolean {
+  const a = textA.toLowerCase();
+  const b = textB.toLowerCase();
+
+  // Pattern: one says "X is Y" and the other says "X is not Y" (or vice versa)
+  const negationPairs = [
+    [/\bnot\b/, /\b(?:always|must|should|is|are|was|were)\b/],
+    [/\bnever\b/, /\b(?:always|every|each)\b/],
+    [/\bdisable/, /\benable/],
+    [/不要|不用|别/, /必须|一定|总是/],
+    [/从不/, /每次|总是|一直/],
+  ];
+
+  for (const [negRe, posRe] of negationPairs) {
+    if ((negRe.test(a) && posRe.test(b)) || (negRe.test(b) && posRe.test(a))) {
+      // Check they share at least one significant term (to avoid false positives)
+      const wordsA = new Set(a.split(/\s+/).filter(w => w.length > 3));
+      const wordsB = new Set(b.split(/\s+/).filter(w => w.length > 3));
+      for (const w of wordsA) {
+        if (wordsB.has(w)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Store interface (duck-typed to avoid hard dependency)
+// ---------------------------------------------------------------------------
+
+type ConsolidationStore = Pick<MemoryStore, "list" | "getById" | "vectorSearch" | "update">;
+
+// ---------------------------------------------------------------------------
+// Engine
+// ---------------------------------------------------------------------------
+
+export class ConsolidationEngine {
+  constructor(
+    private store: ConsolidationStore,
+    private config: ConsolidationConfig = DEFAULT_CONSOLIDATION_CONFIG,
+  ) {}
+
+  async run(scope: string): Promise<ConsolidationResult> {
+    const { clusterThreshold, mergeThreshold, maxEntriesPerRun } = this.config;
+
+    // 1. Fetch entries in scope
+    const entries = await this.store.list([scope], undefined, maxEntriesPerRun, 0);
+    const active = entries.filter(isActive);
+
+    if (active.length === 0) {
+      return { originalCount: 0, clustersFound: 0, mergedCount: 0, relationsAdded: 0, conflictsDetected: [], scope };
+    }
+
+    // 2. Group by category
+    const byCategory = new Map<string, MemoryEntry[]>();
+    for (const e of active) {
+      const cat = e.category;
+      if (!byCategory.has(cat)) byCategory.set(cat, []);
+      byCategory.get(cat)!.push(e);
+    }
+
+    let clustersFound = 0;
+    let mergedCount = 0;
+    let relationsAdded = 0;
+    const conflictsDetected: ConflictEvent[] = [];
+
+    // 3. Cluster within each category
+    for (const [, catEntries] of byCategory) {
+      if (catEntries.length < 2) continue;
+
+      const clustered = new Set<string>();
+      const clusters = new Map<string, string[]>(); // seed ID → member IDs
+
+      for (const entry of catEntries) {
+        if (clustered.has(entry.id)) continue;
+
+        const full = await this.store.getById(entry.id);
+        if (!full?.vector?.length) continue;
+
+        const similar = await this.store.vectorSearch(
+          full.vector, 10, clusterThreshold, [scope],
+        );
+
+        const members = similar.filter(
+          s => s.entry.id !== entry.id && !clustered.has(s.entry.id) && s.entry.category === entry.category,
+        );
+
+        if (members.length === 0) continue;
+
+        const memberIds = [entry.id, ...members.map(s => s.entry.id)];
+        clusters.set(entry.id, memberIds);
+        for (const id of memberIds) clustered.add(id);
+      }
+
+      clustersFound += clusters.size;
+
+      // 4. Process each cluster
+      for (const [, memberIds] of clusters) {
+        const memberEntries: MemoryEntry[] = [];
+        for (const id of memberIds) {
+          const full = await this.store.getById(id);
+          if (full) memberEntries.push(full);
+        }
+        if (memberEntries.length < 2) continue;
+
+        // Determine canonical: highest canonicalScore
+        const sorted = [...memberEntries].sort((a, b) => canonicalScore(b) - canonicalScore(a));
+        const canonical = sorted[0];
+
+        if (!canonical.vector?.length) continue;
+
+        // Get similarity scores relative to canonical
+        const pairResults = await this.store.vectorSearch(
+          canonical.vector, memberEntries.length + 5, clusterThreshold, [scope],
+        );
+        const scoreMap = new Map<string, number>();
+        for (const r of pairResults) scoreMap.set(r.entry.id, r.score);
+
+        for (const member of sorted.slice(1)) {
+          const sim = scoreMap.get(member.id) ?? clusterThreshold;
+
+          if (sim >= mergeThreshold) {
+            // Tier 3.3: Version coexistence instead of SUPERSEDE.
+            // Both entries stay active but are grouped — retrieval picks the best.
+            await createVersionGroup(this.store, canonical, member, scope);
+            mergedCount++;
+          } else {
+            // Link: add clustered_with relation
+            const memberMeta = parseMetadata(member);
+            memberMeta.clustered_with = canonical.id;
+            await this.store.update(member.id, { metadata: JSON.stringify(memberMeta) }, [scope]);
+
+            const canonMeta = parseMetadata(canonical);
+            if (!Array.isArray(canonMeta.cluster_members)) canonMeta.cluster_members = [];
+            if (!(canonMeta.cluster_members as string[]).includes(member.id)) {
+              (canonMeta.cluster_members as string[]).push(member.id);
+            }
+            await this.store.update(canonical.id, { metadata: JSON.stringify(canonMeta) }, [scope]);
+            relationsAdded++;
+          }
+        }
+
+        // Conflict detection within cluster
+        for (let i = 0; i < memberEntries.length; i++) {
+          for (let j = i + 1; j < memberEntries.length; j++) {
+            if (detectHeuristicContradiction(memberEntries[i].text, memberEntries[j].text)) {
+              conflictsDetected.push({
+                memoryA: memberEntries[i].id,
+                memoryB: memberEntries[j].id,
+                type: "heuristic_contradiction",
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return { originalCount: active.length, clustersFound, mergedCount, relationsAdded, conflictsDetected, scope };
+  }
+}
+
+/** Format a ConsolidationResult for display. */
+export function formatConsolidationResult(result: ConsolidationResult): string {
+  const lines = [
+    `Consolidation complete for scope: ${result.scope}`,
+    `Scanned: ${result.originalCount} active entries`,
+    `Clusters found: ${result.clustersFound}`,
+    `Merged (versioned): ${result.mergedCount}`,
+    `Relations added: ${result.relationsAdded}`,
+    `Conflicts detected: ${result.conflictsDetected.length}`,
+  ];
+  if (result.conflictsDetected.length > 0) {
+    lines.push("", "Conflicts:");
+    for (const c of result.conflictsDetected) {
+      lines.push(`  ${c.type}: ${c.memoryA.slice(0, 8)} ↔ ${c.memoryB.slice(0, 8)}`);
+    }
+  }
+  return lines.join("\n");
+}

package/src/context-composer-pins.ts

@@ -0,0 +1,183 @@
+import type { PinAsset } from "./memory-assets.js";
+import { extractBoundaryMetadata, extractCanonicalKey } from "./memory-boundaries.js";
+import { buildProjectScopeCueTerms, normalizeScopedValue } from "./context-composer-scope.js";
+import { cleanText, dedupeText, stripConversationMarkers } from "./context-composer-text.js";
+import {
+  TASK_CUE_EXTRACTION_LIMIT,
+  buildTaskHintTerms,
+  containsLowSignalStableTerm,
+  extractTerms,
+  looksLikeLowSignalTaskResult,
+  looksLikePlanishTaskResult,
+  looksLikeStableInstruction,
+  normalizeText,
+} from "./term-registry.js";
+
+function isUsefulPinnedTaskTerm(term: string): boolean {
+  const normalized = normalizeText(term);
+  if (!normalized) return false;
+  if (looksLikeStableInstruction(normalized)) return false;
+  if (containsLowSignalStableTerm(normalized)) return false;
+  if (normalized.includes("刚才")) return false;
+  if (normalized.endsWith("那个") || normalized === "那个") return false;
+  if (["窗口", "window", "系统", "system", "项目", "project"].includes(normalized)) return false;
+
+  if (/[\p{Script=Han}]/u.test(term)) {
+    return normalized.length >= 3;
+  }
+
+  return normalized.length >= 4;
+}
+
+function scorePin(asset: PinAsset, taskTerms: string[], scope?: string): number {
+  let score = 0;
+  const haystack = `${asset.title} ${asset.summary} ${asset.tags.join(" ")}`.toLowerCase();
+  for (const term of taskTerms) {
+    if (haystack.includes(term)) score += 2;
+  }
+  if (scope && asset.source.scope === scope) score += 3;
+  return score;
+}
+
+function formatPinnedContext(asset: PinAsset, taskTerms: string[]): string {
+  const title = asset.title.trim();
+  const summary = asset.summary.trim();
+  const hasStandaloneTitle = title.length > 0 && !title.startsWith("[");
+  const base = hasStandaloneTitle && summary && !normalizeText(summary).includes(normalizeText(title))
+    ? `Pinned: ${title}: ${summary}`
+    : `Pinned: ${summary || title}`;
+
+  const combined = `${title} ${summary} ${asset.tags.join(" ")}`.toLowerCase();
+  const snippet = cleanText(stripConversationMarkers(asset.snippet), 120);
+  const shouldAppendSnippet = Boolean(
+    snippet &&
+    taskTerms.some((term) => {
+      const normalized = normalizeText(term);
+      return normalized.length >= 2 && snippet.toLowerCase().includes(normalized) && !combined.includes(normalized);
+    }),
+  );
+
+  return cleanText(
+    shouldAppendSnippet
+      ? `${base} Snippet: ${snippet}`
+      : base,
+    220,
+  );
+}
+
+function isDurablePinAsset(asset: PinAsset): boolean {
+  if (asset.type === "pinned-memory") return true;
+
+  const metadata = JSON.stringify(asset.source.metadata || {});
+  const boundary = extractBoundaryMetadata(metadata);
+  if (boundary?.layer === "durable") return true;
+  if (extractCanonicalKey(metadata)) return true;
+  return asset.source.scope.startsWith("memory:") || asset.source.scope.startsWith("asset:");
+}
+
+function looksLikeConversationalPinnedText(text: string): boolean {
+  const normalized = normalizeText(text);
+  if (!normalized) return true;
+  if (looksLikeStableInstruction(normalized)) return true;
+  if (looksLikePlanishTaskResult(normalized)) return true;
+  if (looksLikeLowSignalTaskResult(normalized)) return true;
+
+  return [
+    "现在看",
+    "现在查",
+    "现在更新",
+    "现在修改",
+    "现在修",
+    "现在补",
+    "现在排查",
+    "现在确认",
+    "现在检查",
+    "现在同步",
+    "现在处理",
+    "刚才",
+    "刚刚",
+    "i'll",
+    "i will",
+    "let me",
+    "going to",
+  ].some((prefix) => normalized.startsWith(prefix));
+}
+
+function isConversationalPinnedAsset(asset: PinAsset): boolean {
+  const rawLead = `${asset.title} ${asset.summary}`.trim();
+  if (!/^\[(用户|助手|Pinned Asset|Memory Brief)\]/i.test(rawLead)) return false;
+  if (looksLikeConversationalPinnedText(stripConversationMarkers(rawLead))) return true;
+  return !isDurablePinAsset(asset) || !asset.source.scope.startsWith("memory:");
+}
+
+function isUsefulPinnedAsset(asset: PinAsset): boolean {
+  if (isConversationalPinnedAsset(asset)) return false;
+
+  const stripped = stripConversationMarkers(`${asset.title} ${asset.summary}`);
+  const normalized = normalizeText(stripped);
+  if (!normalized || normalized.length < 8) return false;
+  if (looksLikeStableInstruction(normalized)) return false;
+  if (containsLowSignalStableTerm(normalized)) return false;
+  return true;
+}
+
+function isRelevantToScopedPinnedContext(asset: PinAsset, scope?: string): boolean {
+  if (!scope) return true;
+
+  const requestScope = normalizeScopedValue(scope);
+  const assetScope = normalizeScopedValue(asset.source.scope);
+  if (assetScope === requestScope) return true;
+
+  const requestIsProject = requestScope.startsWith("project:");
+  const assetIsProject = assetScope.startsWith("project:");
+  if (!requestIsProject || !assetIsProject) return true;
+
+  const cueTerms = buildProjectScopeCueTerms(scope);
+  if (cueTerms.length === 0) return false;
+
+  const haystack = normalizeText(stripConversationMarkers(`${asset.title} ${asset.summary} ${asset.tags.join(" ")}`));
+  return cueTerms.some((term) => haystack.includes(term));
+}
+
+export function selectPinnedContext(
+  assets: Array<PinAsset & { path: string }>,
+  params: {
+    taskSeed?: string;
+    scope?: string;
+    limit: number;
+    styleFocused?: boolean;
+    skipForStyleTask?: boolean;
+  },
+): string[] {
+  const { taskSeed, scope, limit, styleFocused, skipForStyleTask } = params;
+  if (styleFocused && skipForStyleTask) {
+    return [];
+  }
+
+  const taskTerms = dedupeText([
+    ...buildTaskHintTerms(taskSeed),
+    ...extractTerms(taskSeed, TASK_CUE_EXTRACTION_LIMIT).filter((term) => isUsefulPinnedTaskTerm(term)),
+    ...(styleFocused ? ["写作", "文章", "风格", "语气", "口语化", "不端着", "自嘲", "style", "tone", "voice"] : []),
+  ], 24);
+  const requirePositiveMatch = taskTerms.length > 0 || Boolean(scope);
+  const ranked = assets
+    .filter((asset) => isUsefulPinnedAsset(asset) && isRelevantToScopedPinnedContext(asset, scope))
+    .map((asset, index) => ({
+      asset,
+      score: scorePin(asset, taskTerms, scope)
+        + ((styleFocused && isDurablePinAsset(asset)) ? 2 : 0)
+        - index * 0.01,
+    }))
+    .filter((item) =>
+      (!requirePositiveMatch || item.score > 0) &&
+      (!styleFocused || isDurablePinAsset(item.asset)),
+    )
+    .sort((a, b) => b.score - a.score);
+
+  return dedupeText(
+    ranked
+      .slice(0, Math.max(limit * 2, 4))
+      .map(({ asset }) => formatPinnedContext(asset, taskTerms)),
+    limit,
+  );
+}