pi-anchor 0.2.4 → 0.4.0

package/dist/extension.cjs

@@ -39,32 +39,14 @@ var import_typebox = require("@sinclair/typebox");
 
 // src/store.ts
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var import_node_os = __toESM(require("os"), 1);
 
 // src/types.ts
-var EPHEMERAL_DECAY_POLICY = {
-  activeDays: 1,
-  // 24 hours active
-  sleepDays: 1,
-  // 24 hours sleeping
-  graveyardDays: 2
-  // 48 hours total before auto-clearing
-};
-var DURABLE_DECAY_POLICY = {
-  activeDays: 3,
-  sleepDays: 30,
-  graveyardDays: 9999
-  // Never permanently auto-dropped; preserved indefinitely
-};
+var QUIET_AFTER_DAYS = 7;
+var MS_PER_DAY = 864e5;
 
-// src/matcher.ts
-var import_node_path = __toESM(require("path"), 1);
-function globToRegExp(pattern) {
-  const collapsed = pattern.slice(0, 512).replace(/\/+(\*\*\/+)+/g, "/**/").replace(/\*{3,}/g, "**");
-  const escaped = collapsed.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*\//g, "___GLOB_DIR_SLASH___").replace(/\*\*/g, "___GLOB_STAR_STAR___").replace(/\*/g, "[^/]*").replace(/___GLOB_DIR_SLASH___/g, "(?:/|/(?:[^/]+/)+)").replace(/___GLOB_STAR_STAR___/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
+// src/store.ts
 function normalizePath(filePath, baseCwd) {
   if (typeof filePath !== "string") return "";
   let norm = filePath.trim().replace(/\\/g, "/").replace(/^\.\//, "");
@@ -80,14 +62,51 @@ function normalizePath(filePath, baseCwd) {
   }
   return norm;
 }
-function isSameOrSubPath(anchorCwd, targetCwd) {
-  if (!anchorCwd || !targetCwd) return false;
-  const normA = anchorCwd.trim().replace(/\\/g, "/").replace(/\/+$/, "");
-  const normT = targetCwd.trim().replace(/\\/g, "/").replace(/\/+$/, "");
-  const isWinStyle = process.platform === "win32" || /^[a-zA-Z]:\//.test(normA) || /^[a-zA-Z]:\//.test(normT);
-  const cmpA = isWinStyle ? normA.toLowerCase() : normA;
-  const cmpT = isWinStyle ? normT.toLowerCase() : normT;
-  return cmpA === cmpT || cmpT.startsWith(cmpA + "/") || cmpA.startsWith(cmpT + "/");
+function isSameOrSubPath(dirA, dirB) {
+  if (!dirA || !dirB) return false;
+  const normA = dirA.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+  const normB = dirB.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+  const isWin = process.platform === "win32" || /^[a-zA-Z]:\//.test(normA) || /^[a-zA-Z]:\//.test(normB);
+  const a = isWin ? normA.toLowerCase() : normA;
+  const b = isWin ? normB.toLowerCase() : normB;
+  return a === b || b.startsWith(a + "/") || a.startsWith(b + "/");
+}
+function globToRegExp(pattern) {
+  const collapsed = pattern.slice(0, 512).replace(/\/+(\*\*\/+)+/g, "/**/").replace(/\*{3,}/g, "**");
+  const escaped = collapsed.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*\//g, "___GLOB_DIR_SLASH___").replace(/\*\*/g, "___GLOB_STAR_STAR___").replace(/\*/g, "[^/]*").replace(/___GLOB_DIR_SLASH___/g, "(?:/|/(?:[^/]+/)+)").replace(/___GLOB_STAR_STAR___/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function extractPathsFromText(text) {
+  if (!text) return [];
+  const results = /* @__PURE__ */ new Set();
+  const regex = /(?:[a-zA-Z]:[\\/][^\s"'`，。；！？、,;)>\]]+|(?:\b(?:src|lib|dist|tests|test|docs|scripts|packages|extensions|bin|assets)[\\/][^\s"'`，。；！？、,;)>\]]+)|(?:\b[\w.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|rs|go|java|c|cpp|h|cs|md|json|yaml|yml|toml|html|css|sql|sh)\b))/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const cleaned = normalizePath(match[0].replace(/[.:;,'")\]}>]+$/, ""));
+    if (cleaned && cleaned.length >= 3) {
+      results.add(cleaned);
+    }
+  }
+  return Array.from(results);
+}
+function isAnchorTargetingWorkspace(anchor, targetCwd) {
+  if (!targetCwd) return true;
+  const normTarget = targetCwd.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+  const targetBase = import_node_path.default.basename(normTarget).toLowerCase();
+  if (anchor.project && anchor.project !== "global") {
+    const normProj = anchor.project.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    if (isSameOrSubPath(normProj, normTarget)) return true;
+    if (import_node_path.default.basename(normProj).toLowerCase() === targetBase) return true;
+  }
+  if (anchor.files && anchor.files.length > 0) {
+    for (const f of anchor.files) {
+      if (isSameOrSubPath(f, normTarget)) return true;
+    }
+  }
+  if (anchor.cwd && isSameOrSubPath(anchor.cwd, normTarget)) {
+    return true;
+  }
+  return false;
 }
 function matchAnchorAgainstTouchedFiles(anchor, touchedFiles) {
   if (!anchor.files || anchor.files.length === 0) return null;
@@ -102,12 +121,9 @@ function matchAnchorAgainstTouchedFiles(anchor, touchedFiles) {
         matchedExact.push(touched);
         break;
       }
-      if (normPattern.includes("*")) {
-        const regex = globToRegExp(normPattern);
-        if (regex.test(touched)) {
-          matchedExact.push(touched);
-          break;
-        }
+      if (normPattern.includes("*") && globToRegExp(normPattern).test(touched)) {
+        matchedExact.push(touched);
+        break;
       }
       const dirPrefix = normPattern.endsWith("/") ? normPattern : normPattern + "/";
       if (touched.startsWith(dirPrefix)) {
@@ -117,193 +133,136 @@ function matchAnchorAgainstTouchedFiles(anchor, touchedFiles) {
     }
   }
   if (matchedExact.length > 0) {
-    return {
-      anchor,
-      score: 1,
-      matchedFiles: Array.from(new Set(matchedExact)),
-      reason: "exact-file"
-    };
+    return { anchor, score: 1, matchedFiles: Array.from(new Set(matchedExact)), reason: "exact-file" };
   }
   if (matchedPrefix.length > 0) {
-    return {
-      anchor,
-      score: 0.85,
-      matchedFiles: Array.from(new Set(matchedPrefix)),
-      reason: "dir-prefix"
-    };
+    return { anchor, score: 0.85, matchedFiles: Array.from(new Set(matchedPrefix)), reason: "dir-prefix" };
   }
   return null;
 }
 function findMatchedAnchors(anchors, touchedFiles) {
-  const priorityWeight = { p0: 3, p1: 2, p2: 1 };
   const results = [];
   for (const anchor of anchors) {
-    const match = matchAnchorAgainstTouchedFiles(anchor, touchedFiles);
-    if (match) {
-      results.push(match);
-    }
+    const m = matchAnchorAgainstTouchedFiles(anchor, touchedFiles);
+    if (m) results.push(m);
   }
-  return results.sort((a, b) => {
-    if (b.score !== a.score) {
-      return b.score - a.score;
-    }
-    const weightA = priorityWeight[a.anchor.priority] || 0;
-    const weightB = priorityWeight[b.anchor.priority] || 0;
-    if (weightB !== weightA) {
-      return weightB - weightA;
-    }
-    return b.anchor.lastTouchedAt - a.anchor.lastTouchedAt;
-  });
+  return results.sort((a, b) => b.score - a.score);
 }
-
-// src/store.ts
-function detectDurability(title) {
-  const temporalKeywords = [
-    "\u4ECA\u5929",
-    "\u4ECA\u65E5",
-    "\u665A\u4E0A",
-    "\u4ECA\u665A",
-    "\u660E\u5929",
-    "\u540E\u5929",
-    "\u5927\u540E\u5929",
-    "\u7A0D\u540E",
-    "\u5F85\u4F1A",
-    "\u4E0B\u5348",
-    "\u4E0A\u5348",
-    "\u4E34\u65F6",
-    "\u4E00\u4F1A\u513F",
-    "\u7B49\u7B49",
-    "today",
-    "tonight",
-    "tomorrow",
-    "later",
-    "temp",
-    "soon"
-  ];
-  const lower = title.toLowerCase();
-  for (const kw of temporalKeywords) {
-    if (lower.includes(kw)) {
-      return "ephemeral";
-    }
-  }
-  return "durable";
-}
-function getEphemeralDecayPolicy(title) {
-  const lower = title.toLowerCase();
-  if (lower.includes("\u5927\u540E\u5929")) {
-    return { activeDays: 3, sleepDays: 1, graveyardDays: 4 };
-  }
-  if (lower.includes("\u540E\u5929")) {
-    return { activeDays: 2, sleepDays: 1, graveyardDays: 3 };
-  }
-  return { ...EPHEMERAL_DECAY_POLICY };
+var COMMENT_FORMATS = {
+  ".ts": (m) => `// ${m}`,
+  ".tsx": (m) => `// ${m}`,
+  ".js": (m) => `// ${m}`,
+  ".jsx": (m) => `// ${m}`,
+  ".mjs": (m) => `// ${m}`,
+  ".cjs": (m) => `// ${m}`,
+  ".go": (m) => `// ${m}`,
+  ".rs": (m) => `// ${m}`,
+  ".c": (m) => `// ${m}`,
+  ".cpp": (m) => `// ${m}`,
+  ".h": (m) => `// ${m}`,
+  ".cs": (m) => `// ${m}`,
+  ".java": (m) => `// ${m}`,
+  ".kt": (m) => `// ${m}`,
+  ".swift": (m) => `// ${m}`,
+  ".dart": (m) => `// ${m}`,
+  ".py": (m) => `# ${m}`,
+  ".rb": (m) => `# ${m}`,
+  ".sh": (m) => `# ${m}`,
+  ".bash": (m) => `# ${m}`,
+  ".yaml": (m) => `# ${m}`,
+  ".yml": (m) => `# ${m}`,
+  ".toml": (m) => `# ${m}`,
+  ".ps1": (m) => `# ${m}`,
+  ".html": (m) => `<!-- ${m} -->`,
+  ".xml": (m) => `<!-- ${m} -->`,
+  ".svg": (m) => `<!-- ${m} -->`,
+  ".vue": (m) => `<!-- ${m} -->`,
+  ".svelte": (m) => `<!-- ${m} -->`,
+  ".css": (m) => `/* ${m} */`,
+  ".scss": (m) => `/* ${m} */`,
+  ".sql": (m) => `-- ${m}`,
+  ".lua": (m) => `-- ${m}`
+};
+function makeSafeTaskAnnotation(filePath, anchor) {
+  const ext = import_node_path.default.extname(filePath).toLowerCase();
+  const fmt = COMMENT_FORMATS[ext];
+  if (!fmt) return null;
+  const num = anchor.id.replace(/^anc-/, "");
+  return "\n\n" + fmt(`\u2316 Note #${num}: ${anchor.title}`);
 }
-function detectTargetDate(titleOrDate, now = Date.now()) {
-  const lower = titleOrDate.toLowerCase().trim();
-  const MS_DAY = 24 * 60 * 60 * 1e3;
-  if (lower.includes("\u4ECA\u5929") || lower.includes("\u4ECA\u65E5") || lower.includes("\u4ECA\u665A") || lower === "today" || lower === "tonight") {
-    return getTodayDateString(now);
-  }
-  if (lower.includes("\u660E\u5929") || lower === "tomorrow") {
-    return getTodayDateString(now + MS_DAY);
-  }
-  if (lower.includes("\u540E\u5929")) {
-    return getTodayDateString(now + 2 * MS_DAY);
-  }
-  if (lower.includes("\u5927\u540E\u5929")) {
-    return getTodayDateString(now + 3 * MS_DAY);
+function matchesCommitMessage(anchor, commitMessages) {
+  const idLower = anchor.id.toLowerCase();
+  const numId = `#${anchor.id.replace(/^anc-/, "")}`;
+  const title = anchor.title.toLowerCase();
+  let titleTokens = [];
+  if (typeof Intl !== "undefined" && Intl.Segmenter) {
+    try {
+      const seg = new Intl.Segmenter("und", { granularity: "word" });
+      titleTokens = Array.from(seg.segment(title)).filter((s) => s.isWordLike).map((s) => s.segment.trim().toLowerCase()).filter((t) => t.length >= 2);
+    } catch {
+      titleTokens = title.split(/[\s,._\-\/]+/).filter((t) => t.length >= 2);
+    }
+  } else {
+    titleTokens = title.split(/[\s,._\-\/]+/).filter((t) => t.length >= 2);
   }
-  const weekdayMap = {
-    "\u5468\u65E5": 0,
-    "\u661F\u671F\u65E5": 0,
-    "sunday": 0,
-    "sun": 0,
-    "\u5468\u4E00": 1,
-    "\u661F\u671F\u4E00": 1,
-    "monday": 1,
-    "mon": 1,
-    "\u5468\u4E8C": 2,
-    "\u661F\u671F\u4E8C": 2,
-    "tuesday": 2,
-    "tue": 2,
-    "\u5468\u4E09": 3,
-    "\u661F\u671F\u4E09": 3,
-    "wednesday": 3,
-    "wed": 3,
-    "\u5468\u56DB": 4,
-    "\u661F\u671F\u56DB": 4,
-    "thursday": 4,
-    "thu": 4,
-    "\u5468\u4E94": 5,
-    "\u661F\u671F\u4E94": 5,
-    "friday": 5,
-    "fri": 5,
-    "\u5468\u516D": 6,
-    "\u661F\u671F\u516D": 6,
-    "saturday": 6,
-    "sat": 6
-  };
-  const isNextWeek = lower.includes("\u4E0B\u5468") || lower.includes("next");
-  for (const [name, targetDay] of Object.entries(weekdayMap)) {
-    if (lower.includes(name)) {
-      const curDay = new Date(now).getDay();
-      let diff = targetDay - curDay;
-      if (diff <= 0 || isNextWeek) {
-        diff += 7;
+  for (const msg of commitMessages) {
+    const msgLower = msg.toLowerCase();
+    if (msgLower.includes(idLower) || msgLower.includes(numId)) {
+      return { matched: true, message: msg };
+    }
+    if (titleTokens.length > 0) {
+      const hits = titleTokens.filter((tok) => msgLower.includes(tok)).length;
+      if (hits >= Math.min(2, titleTokens.length)) {
+        return { matched: true, message: msg };
       }
-      return getTodayDateString(now + diff * MS_DAY);
     }
   }
-  const fullDateMatch = titleOrDate.match(/\b(20\d\d)-(\d{1,2})-(\d{1,2})\b/);
-  if (fullDateMatch) {
-    const y = fullDateMatch[1];
-    const m = fullDateMatch[2].padStart(2, "0");
-    const d = fullDateMatch[3].padStart(2, "0");
-    return `${y}-${m}-${d}`;
-  }
-  const mmddMatch = titleOrDate.match(/\b(\d{1,2})-(\d{1,2})\b/);
-  if (mmddMatch) {
-    const curYear = new Date(now).getFullYear();
-    const m = mmddMatch[1].padStart(2, "0");
-    const d = mmddMatch[2].padStart(2, "0");
-    return `${curYear}-${m}-${d}`;
-  }
-  return void 0;
-}
-function detectRecurrence(title) {
-  const lower = title.toLowerCase();
-  if (lower.includes("\u6BCF\u5929") || lower.includes("\u6BCF\u65E5") || lower.includes("daily") || lower.includes("every day")) {
-    return "daily";
-  }
-  return void 0;
+  return { matched: false };
 }
-function getTodayDateString(timestamp = Date.now()) {
-  const d = new Date(timestamp);
-  const year = d.getFullYear();
-  const month = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
+function renderColdStartAnchorsContext(store, cwdOrNow, nowArg) {
+  let cwd;
+  let now = Date.now();
+  if (typeof cwdOrNow === "number") now = cwdOrNow;
+  else if (typeof cwdOrNow === "string") cwd = cwdOrNow;
+  if (typeof nowArg === "number") now = nowArg;
+  sweepQuietNotes(store, now);
+  const activeNotes = store.list({ status: "active", cwd });
+  if (activeNotes.length === 0) return "";
+  const lines = activeNotes.map((a) => {
+    const num = a.id.replace(/^anc-/, "");
+    const files = a.files.length > 0 ? ` (${a.files.slice(0, 2).join(", ")})` : "";
+    const desc = a.description ? ` \u2014 ${a.description}` : "";
+    return `\u2022 #${num} [${a.project}] ${a.title}${files}${desc}`;
+  });
+  return [
+    `<sticky-notes count="${activeNotes.length}">`,
+    `Pinned notes from previous sessions:`,
+    lines.join("\n"),
+    `When a note is completed, call anchor(action="settle", id="...") to tear it off.`,
+    `</sticky-notes>`
+  ].join("\n");
 }
-function getDefaultStorageDir() {
-  if (process.env.ANCHOR_DIR) {
-    return import_node_path2.default.resolve(process.env.ANCHOR_DIR);
-  }
-  const primaryDir = import_node_path2.default.join(import_node_os.default.homedir(), ".anchor");
-  const legacyPiDir = import_node_path2.default.join(import_node_os.default.homedir(), ".pi", "agent", "anchors");
-  if (!import_node_fs.default.existsSync(primaryDir) && import_node_fs.default.existsSync(legacyPiDir)) {
-    try {
-      import_node_fs.default.mkdirSync(primaryDir, { recursive: true });
-      for (const file of ["state.json", "archive.jsonl", "graveyard.jsonl"]) {
-        const src = import_node_path2.default.join(legacyPiDir, file);
-        const dest = import_node_path2.default.join(primaryDir, file);
-        if (import_node_fs.default.existsSync(src) && !import_node_fs.default.existsSync(dest)) {
-          import_node_fs.default.copyFileSync(src, dest);
-        }
+function sweepQuietNotes(store, now = Date.now()) {
+  return store.withLock(() => {
+    const state = store.loadState();
+    const quieted = [];
+    for (const a of state.anchors) {
+      if (a.status === "active" && now - a.lastTouchedAt > QUIET_AFTER_DAYS * MS_PER_DAY) {
+        a.status = "sleeping";
+        a.updatedAt = now;
+        quieted.push(a.id);
       }
-    } catch {
     }
-  }
-  return primaryDir;
+    if (quieted.length > 0) {
+      state.lastSweepAt = now;
+      store.saveState(state);
+    }
+    return { quieted };
+  });
+}
+function getDefaultStorageDir() {
+  if (process.env.ANCHOR_DIR) return import_node_path.default.resolve(process.env.ANCHOR_DIR);
+  return import_node_path.default.join(import_node_os.default.homedir(), ".anchor");
 }
 function sleepSync(ms) {
   const end = Date.now() + ms;
@@ -325,22 +284,18 @@ function acquireSyncLock(lockPath, maxWaitMs = 1500, staleTimeoutMs = 5e3) {
     attempt++;
     try {
       const fd = import_node_fs.default.openSync(lockPath, "wx");
-      const meta = { pid: process.pid, createdAt: Date.now() };
-      import_node_fs.default.writeFileSync(fd, JSON.stringify(meta), "utf-8");
+      import_node_fs.default.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: Date.now() }), "utf-8");
       import_node_fs.default.closeSync(fd);
       return () => {
         try {
-          if (import_node_fs.default.existsSync(lockPath)) {
-            import_node_fs.default.unlinkSync(lockPath);
-          }
+          if (import_node_fs.default.existsSync(lockPath)) import_node_fs.default.unlinkSync(lockPath);
         } catch {
         }
       };
     } catch (err) {
       if (err.code === "EEXIST") {
         try {
-          const content = import_node_fs.default.readFileSync(lockPath, "utf-8");
-          const meta = JSON.parse(content);
+          const meta = JSON.parse(import_node_fs.default.readFileSync(lockPath, "utf-8"));
           const isStale = Date.now() - meta.createdAt > staleTimeoutMs;
           const isDead = meta.pid && !isProcessAlive(meta.pid);
           if (isStale || isDead) {
@@ -352,8 +307,7 @@ function acquireSyncLock(lockPath, maxWaitMs = 1500, staleTimeoutMs = 5e3) {
           }
         } catch {
         }
-        const delay = Math.min(40, Math.floor(attempt * 4 + Math.random() * 8));
-        sleepSync(delay);
+        sleepSync(Math.min(40, Math.floor(attempt * 4 + Math.random() * 8)));
         continue;
       }
       break;
@@ -362,50 +316,46 @@ function acquireSyncLock(lockPath, maxWaitMs = 1500, staleTimeoutMs = 5e3) {
   return () => {
   };
 }
-function atomicRenameWithRetry(tempPath, targetPath, maxAttempts = 6) {
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+function atomicRenameWithRetry(tempPath, targetPath, maxRetries = 5) {
+  let lastErr;
+  for (let i = 0; i < maxRetries; i++) {
     try {
       import_node_fs.default.renameSync(tempPath, targetPath);
       return;
     } catch (err) {
-      const code = err?.code;
-      if ((code === "EBUSY" || code === "EPERM" || code === "EACCES") && attempt < maxAttempts) {
-        const delay = Math.floor(attempt * 20 + Math.random() * 15);
-        sleepSync(delay);
+      lastErr = err;
+      if (err.code === "EPERM" || err.code === "EACCES" || err.code === "EBUSY") {
+        sleepSync(15 * (i + 1));
         continue;
       }
-      const crashDump = `${tempPath}.failed`;
-      try {
-        if (import_node_fs.default.existsSync(tempPath)) import_node_fs.default.renameSync(tempPath, crashDump);
-      } catch {
-      }
-      throw err;
+      break;
     }
   }
+  try {
+    import_node_fs.default.copyFileSync(tempPath, targetPath);
+    import_node_fs.default.unlinkSync(tempPath);
+  } catch {
+    throw lastErr;
+  }
 }
 var AnchorStore = class {
   storageDir;
   statePath;
+  lockPath;
   archivePath;
-  graveyardPath;
-  constructor(customStorageDir) {
-    if (customStorageDir) {
-      this.storageDir = import_node_path2.default.resolve(customStorageDir);
-    } else {
-      this.storageDir = getDefaultStorageDir();
-    }
-    this.statePath = import_node_path2.default.join(this.storageDir, "state.json");
-    this.archivePath = import_node_path2.default.join(this.storageDir, "archive.jsonl");
-    this.graveyardPath = import_node_path2.default.join(this.storageDir, "graveyard.jsonl");
-    this.ensureDirs();
+  constructor(storageDir) {
+    this.storageDir = storageDir ? import_node_path.default.resolve(storageDir) : getDefaultStorageDir();
+    this.statePath = import_node_path.default.join(this.storageDir, "state.json");
+    this.lockPath = import_node_path.default.join(this.storageDir, "state.lock");
+    this.archivePath = import_node_path.default.join(this.storageDir, "archive.jsonl");
   }
-  get lockPath() {
-    return import_node_path2.default.join(this.storageDir, "state.lock");
+  ensureDirs() {
+    if (!import_node_fs.default.existsSync(this.storageDir)) {
+      import_node_fs.default.mkdirSync(this.storageDir, { recursive: true });
+    }
   }
-  /**
-   * Execute mutation within a cross-process exclusive lock
-   */
   withLock(fn) {
+    this.ensureDirs();
     const release = acquireSyncLock(this.lockPath);
     try {
       return fn();
@@ -413,84 +363,35 @@ var AnchorStore = class {
       release();
     }
   }
-  ensureDirs() {
-    if (!import_node_fs.default.existsSync(this.storageDir)) {
-      try {
-        import_node_fs.default.mkdirSync(this.storageDir, { recursive: true });
-      } catch {
-      }
-    }
-  }
-  /**
-   * Load store state. If corrupt or missing, returns safe default.
-   */
   loadState() {
     this.ensureDirs();
     if (!import_node_fs.default.existsSync(this.statePath)) {
-      return {
-        version: 1,
-        anchors: [],
-        lastSweepAt: Date.now()
-      };
-    }
-    let raw = null;
-    for (let attempt = 1; attempt <= 3; attempt++) {
-      try {
-        raw = import_node_fs.default.readFileSync(this.statePath, "utf-8");
-        break;
-      } catch (err) {
-        if ((err?.code === "EBUSY" || err?.code === "EPERM") && attempt < 3) {
-          sleepSync(15);
-          continue;
-        }
-      }
-    }
-    if (raw === null) {
-      return { version: 1, anchors: [], lastSweepAt: Date.now() };
+      return { version: 1, anchors: [], lastSweepAt: Date.now(), nextId: 1 };
     }
     try {
-      const data = JSON.parse(raw);
-      if (!data || typeof data !== "object" || !Array.isArray(data.anchors)) {
-        throw new Error("Invalid state: anchors must be array");
+      const parsed = JSON.parse(import_node_fs.default.readFileSync(this.statePath, "utf-8"));
+      if (!parsed || !Array.isArray(parsed.anchors)) {
+        return { version: 1, anchors: [], lastSweepAt: Date.now(), nextId: 1 };
       }
-      data.anchors = data.anchors.filter((a) => a && typeof a === "object" && typeof a.id === "string" && typeof a.title === "string").map((a) => ({
-        ...a,
-        files: Array.isArray(a.files) ? a.files.filter((f) => typeof f === "string") : [],
-        tags: Array.isArray(a.tags) ? a.tags.filter((t) => typeof t === "string") : [],
-        decay: {
-          activeDays: Number.isFinite(a.decay?.activeDays) && a.decay.activeDays > 0 ? a.decay.activeDays : DURABLE_DECAY_POLICY.activeDays,
-          sleepDays: Number.isFinite(a.decay?.sleepDays) && a.decay.sleepDays > 0 ? a.decay.sleepDays : DURABLE_DECAY_POLICY.sleepDays,
-          graveyardDays: Number.isFinite(a.decay?.graveyardDays) && a.decay.graveyardDays > 0 ? a.decay.graveyardDays : DURABLE_DECAY_POLICY.graveyardDays
-        }
-      }));
-      return data;
+      return parsed;
     } catch {
-      const backupPath = import_node_path2.default.join(this.storageDir, `state.corrupt.${Date.now()}.json`);
       try {
-        import_node_fs.default.renameSync(this.statePath, backupPath);
+        import_node_fs.default.copyFileSync(this.statePath, import_node_path.default.join(this.storageDir, `state.corrupt.${Date.now()}.json`));
       } catch {
       }
-      return {
-        version: 1,
-        anchors: [],
-        lastSweepAt: Date.now()
-      };
+      return { version: 1, anchors: [], lastSweepAt: Date.now(), nextId: 1 };
     }
   }
-  /**
-   * Atomically save store state via temp file + atomic rename with Windows NTFS spin-retry
-   */
   saveState(state) {
     this.ensureDirs();
-    const rand = Math.random().toString(36).slice(2, 7);
-    const tempPath = import_node_path2.default.join(this.storageDir, `state.tmp.${process.pid}.${Date.now()}.${rand}`);
+    const tempPath = `${this.statePath}.${process.pid}.${Date.now()}.tmp`;
     import_node_fs.default.writeFileSync(tempPath, JSON.stringify(state, null, 2), "utf-8");
     atomicRenameWithRetry(tempPath, this.statePath);
   }
   generateId(state) {
     const numbers = state.anchors.map((a) => {
-      const match = a.id.match(/^anc-(\d+)$/);
-      return match ? parseInt(match[1], 10) : 0;
+      const m = a.id.match(/^anc-(\d+)$/);
+      return m ? parseInt(m[1], 10) : 0;
     }).filter((n) => n > 0);
     const maxExisting = numbers.length > 0 ? Math.max(...numbers) : 0;
     const nextNum = Math.max(maxExisting + 1, state.nextId || 1);
@@ -498,37 +399,36 @@ var AnchorStore = class {
     return `anc-${nextNum}`;
   }
   /**
-   * Create a new Anchor with automatic project and cwd tagging
+   * Pin a new sticky note
    */
   create(input) {
     return this.withLock(() => {
       const state = this.loadState();
       const now = Date.now();
       const id = this.generateId(state);
-      const cwd = input.cwd ? normalizePath(input.cwd) : "";
-      const projectName = input.project ? input.project.trim() : cwd ? import_node_path2.default.basename(cwd) : "global";
-      const recurrence = input.recurrence || detectRecurrence(input.title);
-      const targetDate = input.targetDate || detectTargetDate(input.title, now);
-      const durability = recurrence ? "durable" : input.durability || detectDurability(input.title);
-      const decayPolicy = durability === "ephemeral" ? getEphemeralDecayPolicy(input.title) : DURABLE_DECAY_POLICY;
+      const explicitFiles = (input.files || []).map((f) => normalizePath(f)).filter(Boolean);
+      const inferredFiles = explicitFiles.length > 0 ? explicitFiles : extractPathsFromText(`${input.title} ${input.description || ""}`);
+      let cwd = input.cwd ? normalizePath(input.cwd) : "";
+      if (input.project && (/^[a-zA-Z]:[\\/]/.test(input.project.trim()) || input.project.trim().startsWith("/"))) {
+        cwd = normalizePath(input.project.trim());
+      } else if (inferredFiles.length > 0 && (/^[a-zA-Z]:\//.test(inferredFiles[0]) || inferredFiles[0].startsWith("/"))) {
+        const firstDir = import_node_path.default.dirname(inferredFiles[0]);
+        if (firstDir && firstDir !== ".") cwd = normalizePath(firstDir);
+      }
+      const projectName = input.project ? input.project.trim() : cwd ? import_node_path.default.basename(cwd) : "global";
       const anchor = {
         id,
         title: input.title.trim(),
         description: input.description?.trim(),
         priority: input.priority || "p1",
         status: "active",
-        durability,
-        recurrence,
-        targetDate,
         project: projectName,
         cwd,
         createdAt: now,
         updatedAt: now,
         lastTouchedAt: now,
-        files: (input.files || []).map((f) => normalizePath(f)).filter(Boolean),
-        tags: (input.tags || []).map((t) => t.trim()).filter(Boolean),
-        verifyCommand: input.verifyCommand?.trim() || void 0,
-        decay: input.decay ? { ...input.decay } : { ...decayPolicy }
+        files: inferredFiles,
+        tags: (input.tags || []).map((t) => t.trim()).filter(Boolean)
       };
       state.anchors.push(anchor);
       this.saveState(state);
@@ -538,52 +438,34 @@ var AnchorStore = class {
   findAnchorIndex(anchors, id) {
     const clean = id.trim().replace(/^#/, "");
     return anchors.findIndex(
-      (a) => a.id === clean || a.id === `anc-${clean}` || (clean.match(/^\d+$/) ? a.id === `anc-${parseInt(clean, 10)}` : false)
+      (a) => a.id === clean || a.id === `anc-${clean}` || (/^\d+$/.test(clean) ? a.id === `anc-${parseInt(clean, 10)}` : false)
     );
   }
-  /**
-   * Get an anchor by ID (supports 'anc-1', '#anc-1', '1', '01')
-   */
   get(id) {
     const state = this.loadState();
     const idx = this.findAnchorIndex(state.anchors, id);
     return idx === -1 ? void 0 : state.anchors[idx];
   }
-  /**
-   * List anchors. By default, if cwd is provided, only returns anchors
-   * belonging to this cwd or marked as global (''). Pass all: true for global view.
-   */
   list(filter) {
     const state = this.loadState();
     const targetCwd = filter?.cwd ? normalizePath(filter.cwd) : null;
-    const today = getTodayDateString(filter?.now);
     return state.anchors.filter((a) => {
-      if (!filter?.all && filter?.status === "active" && a.recurrence === "daily" && a.lastCompletedDate === today) {
-        return false;
-      }
       if (filter?.status && a.status !== filter.status) return false;
-      if (filter?.priority && a.priority !== filter.priority) return false;
       if (!filter?.all && targetCwd) {
-        if (a.files.length > 0 && a.cwd && !isSameOrSubPath(a.cwd, targetCwd)) {
+        if (a.files.length > 0 && (a.cwd || a.project) && !isAnchorTargetingWorkspace(a, targetCwd)) {
           return false;
         }
       }
       return true;
     });
   }
-  /**
-   * Update an existing anchor
-   */
   update(id, patch) {
     return this.withLock(() => {
       const state = this.loadState();
       const idx = this.findAnchorIndex(state.anchors, id);
-      if (idx === -1) {
-        throw new Error(`Anchor not found: ${id}`);
-      }
-      const current = state.anchors[idx];
+      if (idx === -1) throw new Error(`Note not found: ${id}`);
       const updated = {
-        ...current,
+        ...state.anchors[idx],
         ...patch,
         updatedAt: Date.now()
       };
@@ -595,16 +477,11 @@ var AnchorStore = class {
       return updated;
     });
   }
-  /**
-   * Touch an anchor to refresh its decay window and reactivate sleeping state
-   */
   touch(id, timestamp = Date.now()) {
     return this.withLock(() => {
       const state = this.loadState();
       const idx = this.findAnchorIndex(state.anchors, id);
-      if (idx === -1) {
-        throw new Error(`Anchor not found: ${id}`);
-      }
+      if (idx === -1) throw new Error(`Note not found: ${id}`);
       const current = state.anchors[idx];
       current.lastTouchedAt = timestamp;
       current.updatedAt = timestamp;
@@ -617,38 +494,20 @@ var AnchorStore = class {
     });
   }
   /**
-   * Settle an anchor (recurring daily habits complete for today and wake up tomorrow)
+   * Tear off (settle) a completed sticky note and archive it to archive.jsonl
    */
   settle(id, evidence = {}, now = Date.now()) {
     return this.withLock(() => {
       const state = this.loadState();
       const idx = this.findAnchorIndex(state.anchors, id);
-      if (idx === -1) {
-        throw new Error(`Anchor not found: ${id}`);
-      }
-      const anchor = state.anchors[idx];
-      const today = getTodayDateString(now);
-      if (anchor.recurrence === "daily") {
-        anchor.lastCompletedDate = today;
-        anchor.lastTouchedAt = now;
-        anchor.updatedAt = now;
-        anchor.evidence = {
-          ...evidence,
-          settledAt: now,
-          settledBy: evidence.settledBy || "manual-command"
-        };
-        this.ensureDirs();
-        import_node_fs.default.appendFileSync(this.archivePath, JSON.stringify({ ...anchor, settledForDate: today }) + "\n", "utf-8");
-        this.saveState(state);
-        return anchor;
-      }
+      if (idx === -1) throw new Error(`Note not found: ${id}`);
       const [settled] = state.anchors.splice(idx, 1);
       settled.status = "settled";
       settled.updatedAt = now;
       settled.evidence = {
         ...evidence,
         settledAt: now,
-        settledBy: evidence.settledBy || "manual-command"
+        settledBy: evidence.settledBy || "manual"
       };
       this.ensureDirs();
       import_node_fs.default.appendFileSync(this.archivePath, JSON.stringify(settled) + "\n", "utf-8");
@@ -657,12 +516,12 @@ var AnchorStore = class {
     });
   }
   /**
-   * Reverse/undo the last settled anchor, popping it from archive.jsonl back into state.json
+   * Put back (undo) the last torn-off sticky note
    */
   undoSettle() {
     return this.withLock(() => {
       if (!import_node_fs.default.existsSync(this.archivePath)) {
-        throw new Error("No archived anchors to undo");
+        throw new Error("No archived notes to restore");
       }
       const raw = import_node_fs.default.readFileSync(this.archivePath, "utf-8");
       const lines = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
@@ -671,23 +530,18 @@ var AnchorStore = class {
         const candidate = lines.pop();
         try {
           const parsed = JSON.parse(candidate);
-          if (parsed && typeof parsed === "object" && typeof parsed.id === "string" && typeof parsed.title === "string") {
+          if (parsed && typeof parsed.id === "string" && typeof parsed.title === "string") {
             anchor = parsed;
           }
         } catch {
         }
       }
-      if (!anchor) {
-        throw new Error("Archive is empty, nothing to undo");
-      }
+      if (!anchor) throw new Error("Archive is empty, nothing to undo");
       import_node_fs.default.writeFileSync(this.archivePath, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
       anchor.status = "active";
       anchor.updatedAt = Date.now();
+      anchor.lastTouchedAt = Date.now();
       delete anchor.evidence;
-      delete anchor.settledForDate;
-      if (anchor.recurrence === "daily") {
-        delete anchor.lastCompletedDate;
-      }
       const state = this.loadState();
       const existingIdx = state.anchors.findIndex((a) => a.id === anchor.id);
       if (existingIdx !== -1) {
@@ -698,473 +552,18 @@ var AnchorStore = class {
           state.anchors.push(anchor);
         }
       } else {
-        const match = anchor.id.match(/^anc-(\d+)$/);
-        if (match) {
-          const restoredNum = parseInt(match[1], 10);
-          state.nextId = Math.max(state.nextId || 1, restoredNum + 1);
-        }
+        const m = anchor.id.match(/^anc-(\d+)$/);
+        if (m) state.nextId = Math.max(state.nextId || 1, parseInt(m[1], 10) + 1);
         state.anchors.push(anchor);
       }
       this.saveState(state);
       return anchor;
     });
   }
-  /**
-   * Evict anchor to graveyard.jsonl upon total decay expiry
-   */
-  dropToGraveyard(id, reason) {
-    return this.withLock(() => {
-      const state = this.loadState();
-      const idx = state.anchors.findIndex((a) => a.id === id);
-      if (idx === -1) {
-        throw new Error(`Anchor not found: ${id}`);
-      }
-      const [anchor] = state.anchors.splice(idx, 1);
-      anchor.status = "graveyard";
-      anchor.updatedAt = Date.now();
-      anchor.evidence = {
-        summary: reason,
-        settledAt: Date.now()
-      };
-      this.ensureDirs();
-      import_node_fs.default.appendFileSync(this.graveyardPath, JSON.stringify(anchor) + "\n", "utf-8");
-      this.saveState(state);
-      return anchor;
-    });
-  }
-  getArchive(filter) {
-    if (!import_node_fs.default.existsSync(this.archivePath)) return [];
-    try {
-      const raw = import_node_fs.default.readFileSync(this.archivePath, "utf-8");
-      const all = [];
-      for (const l of raw.split(/\r?\n/)) {
-        const trimmed = l.trim();
-        if (!trimmed) continue;
-        try {
-          const parsed = JSON.parse(trimmed);
-          if (parsed && typeof parsed === "object" && typeof parsed.id === "string") all.push(parsed);
-        } catch {
-        }
-      }
-      if (filter?.all || !filter?.cwd) return all;
-      const targetCwd = normalizePath(filter.cwd);
-      return all.filter((a) => !a.cwd || isSameOrSubPath(a.cwd, targetCwd));
-    } catch {
-      return [];
-    }
-  }
-  getGraveyard(filter) {
-    if (!import_node_fs.default.existsSync(this.graveyardPath)) return [];
-    try {
-      const raw = import_node_fs.default.readFileSync(this.graveyardPath, "utf-8");
-      const all = [];
-      for (const l of raw.split(/\r?\n/)) {
-        const trimmed = l.trim();
-        if (!trimmed) continue;
-        try {
-          const parsed = JSON.parse(trimmed);
-          if (parsed && typeof parsed === "object" && typeof parsed.id === "string") all.push(parsed);
-        } catch {
-        }
-      }
-      if (filter?.all || !filter?.cwd) return all;
-      const targetCwd = normalizePath(filter.cwd);
-      return all.filter((a) => !a.cwd || isSameOrSubPath(a.cwd, targetCwd));
-    } catch {
-      return [];
-    }
-  }
 };
 
-// src/observer.ts
-var MUTATION_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "patch", "apply_diff", "create_file", "modify"]);
-var SessionTouchObserver = class {
-  touchedFiles = /* @__PURE__ */ new Set();
-  modifiedFiles = /* @__PURE__ */ new Set();
-  inspectedFiles = /* @__PURE__ */ new Set();
-  committed = false;
-  commitMessages = [];
-  clear() {
-    this.touchedFiles.clear();
-    this.modifiedFiles.clear();
-    this.inspectedFiles.clear();
-    this.committed = false;
-    this.commitMessages = [];
-  }
-  /**
-   * Observe and record a tool call invocation, separating inspection from mutation
-   */
-  recordToolCall(toolName, input) {
-    if (!input || typeof input !== "object") return;
-    const lowerTool = (toolName || "").toLowerCase();
-    const isMutation = MUTATION_TOOLS.has(lowerTool);
-    const paths = [];
-    const pathField = input.path || input.filePath || input.file;
-    if (typeof pathField === "string") {
-      paths.push(normalizePath(pathField));
-    }
-    if (Array.isArray(input.paths)) {
-      for (const p of input.paths) {
-        if (typeof p === "string") {
-          paths.push(normalizePath(p));
-        }
-      }
-    }
-    for (const p of paths) {
-      this.touchedFiles.add(p);
-      if (isMutation) {
-        this.modifiedFiles.add(p);
-      } else {
-        this.inspectedFiles.add(p);
-      }
-    }
-    if (lowerTool === "bash" || lowerTool === "powershell") {
-      const cmd = String(input.command || "");
-      if (cmd.includes("git commit")) {
-        this.committed = true;
-        const msgMatch = cmd.match(/-m\s+["']([^"']+)["']/);
-        if (msgMatch && msgMatch[1]) {
-          this.commitMessages.push(msgMatch[1]);
-        }
-      }
-    }
-  }
-  /**
-   * Add a file path manually (e.g. from git status diff)
-   */
-  addTouchedFile(filePath, isModified = true) {
-    if (filePath) {
-      const norm = normalizePath(filePath);
-      this.touchedFiles.add(norm);
-      if (isModified) {
-        this.modifiedFiles.add(norm);
-      } else {
-        this.inspectedFiles.add(norm);
-      }
-    }
-  }
-  getModifiedFiles() {
-    return Array.from(this.modifiedFiles);
-  }
-  getInspectedFiles() {
-    return Array.from(this.inspectedFiles);
-  }
-  getTouchedFiles() {
-    return Array.from(this.touchedFiles);
-  }
-  hasCommitted() {
-    return this.committed;
-  }
-  getCommitMessages() {
-    return [...this.commitMessages];
-  }
-  /**
-   * Check if any commit message explicitly references or resolves an anchor
-   */
-  matchesCommit(anchor) {
-    const idLower = anchor.id.toLowerCase();
-    const title = anchor.title.toLowerCase();
-    let titleTokens = [];
-    if (typeof Intl !== "undefined" && Intl.Segmenter) {
-      try {
-        const segmenter = new Intl.Segmenter("und", { granularity: "word" });
-        titleTokens = Array.from(segmenter.segment(title)).filter((s) => s.isWordLike).map((s) => s.segment.trim().toLowerCase()).filter((t) => t.length >= 2);
-      } catch {
-        titleTokens = title.split(/[\s,._\-\/]+/).filter((t) => t.length >= 2);
-      }
-    } else {
-      titleTokens = title.split(/[\s,._\-\/]+/).filter((t) => t.length >= 2);
-    }
-    for (const msg of this.commitMessages) {
-      const msgLower = msg.toLowerCase();
-      if (msgLower.includes(idLower)) {
-        return { matched: true, message: msg };
-      }
-      if (titleTokens.length > 0) {
-        const matchingCount = titleTokens.filter((tok) => msgLower.includes(tok)).length;
-        if (matchingCount >= Math.min(2, titleTokens.length)) {
-          return { matched: true, message: msg };
-        }
-      }
-    }
-    return { matched: false };
-  }
-};
-
-// src/decay.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var MS_PER_DAY = 864e5;
-function evaluateAnchorDecay(anchor, now = Date.now()) {
-  if (anchor.status === "settled" || anchor.status === "graveyard") {
-    return {
-      currentStatus: anchor.status,
-      nextStatus: anchor.status,
-      daysUntouched: 0,
-      remainingActiveDays: 0,
-      remainingSleepDays: 0
-    };
-  }
-  const elapsedMs = Math.max(0, now - anchor.lastTouchedAt);
-  const daysUntouched = elapsedMs / MS_PER_DAY;
-  const activeDays = anchor.decay.activeDays;
-  const graveyardDays = anchor.decay.graveyardDays;
-  let nextStatus = anchor.status;
-  if (daysUntouched <= activeDays) {
-    nextStatus = "active";
-  } else if (daysUntouched <= graveyardDays) {
-    nextStatus = "sleeping";
-  } else {
-    nextStatus = "graveyard";
-  }
-  return {
-    currentStatus: anchor.status,
-    nextStatus,
-    daysUntouched: Math.round(daysUntouched * 10) / 10,
-    remainingActiveDays: Math.max(0, Math.round((activeDays - daysUntouched) * 10) / 10),
-    remainingSleepDays: Math.max(0, Math.round((graveyardDays - daysUntouched) * 10) / 10)
-  };
-}
-function sweepStore(store, now = Date.now()) {
-  return store.withLock(() => {
-    const state = store.loadState();
-    const result = {
-      transitionedToSleeping: [],
-      wokenToActive: [],
-      evictedToGraveyard: []
-    };
-    const toEvict = [];
-    let stateModified = false;
-    for (const anchor of state.anchors) {
-      const evalResult = evaluateAnchorDecay(anchor, now);
-      if (evalResult.nextStatus === "graveyard") {
-        toEvict.push(anchor);
-      } else if (evalResult.nextStatus !== anchor.status) {
-        if (evalResult.nextStatus === "sleeping" && anchor.status === "active") {
-          anchor.status = "sleeping";
-          anchor.updatedAt = now;
-          result.transitionedToSleeping.push(anchor.id);
-          stateModified = true;
-        } else if (evalResult.nextStatus === "active" && anchor.status === "sleeping") {
-          anchor.status = "active";
-          anchor.updatedAt = now;
-          result.wokenToActive.push(anchor.id);
-          stateModified = true;
-        }
-      }
-    }
-    if (toEvict.length > 0) {
-      const evictIds = new Set(toEvict.map((e) => e.id));
-      state.anchors = state.anchors.filter((a) => !evictIds.has(a.id));
-      stateModified = true;
-      const graveyardLines = toEvict.map((exp) => {
-        const rec = {
-          ...exp,
-          status: "graveyard",
-          updatedAt: now,
-          evictedAt: now,
-          evictionReason: `Exceeded decay threshold (${exp.decay.graveyardDays} days untouched)`
-        };
-        return JSON.stringify(rec);
-      }).join("\n") + "\n";
-      import_node_fs2.default.appendFileSync(store.graveyardPath, graveyardLines, "utf-8");
-      for (const exp of toEvict) {
-        result.evictedToGraveyard.push(exp.id);
-      }
-    }
-    state.lastSweepAt = now;
-    if (stateModified) {
-      store.saveState(state);
-    }
-    return result;
-  });
-}
-
-// src/context_injector.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var COMMENT_FORMATS = {
-  // Double slash //
-  ".ts": (m) => `// ${m}`,
-  ".tsx": (m) => `// ${m}`,
-  ".js": (m) => `// ${m}`,
-  ".jsx": (m) => `// ${m}`,
-  ".mjs": (m) => `// ${m}`,
-  ".cjs": (m) => `// ${m}`,
-  ".java": (m) => `// ${m}`,
-  ".kt": (m) => `// ${m}`,
-  ".swift": (m) => `// ${m}`,
-  ".go": (m) => `// ${m}`,
-  ".rs": (m) => `// ${m}`,
-  ".c": (m) => `// ${m}`,
-  ".cpp": (m) => `// ${m}`,
-  ".h": (m) => `// ${m}`,
-  ".hpp": (m) => `// ${m}`,
-  ".cs": (m) => `// ${m}`,
-  ".dart": (m) => `// ${m}`,
-  ".scala": (m) => `// ${m}`,
-  ".zig": (m) => `// ${m}`,
-  ".proto": (m) => `// ${m}`,
-  // Hash #
-  ".py": (m) => `# ${m}`,
-  ".rb": (m) => `# ${m}`,
-  ".sh": (m) => `# ${m}`,
-  ".bash": (m) => `# ${m}`,
-  ".zsh": (m) => `# ${m}`,
-  ".yaml": (m) => `# ${m}`,
-  ".yml": (m) => `# ${m}`,
-  ".toml": (m) => `# ${m}`,
-  ".conf": (m) => `# ${m}`,
-  ".dockerfile": (m) => `# ${m}`,
-  ".ps1": (m) => `# ${m}`,
-  ".r": (m) => `# ${m}`,
-  // HTML / XML <!-- -->
-  ".html": (m) => `<!-- ${m} -->`,
-  ".xml": (m) => `<!-- ${m} -->`,
-  ".svg": (m) => `<!-- ${m} -->`,
-  ".vue": (m) => `<!-- ${m} -->`,
-  ".svelte": (m) => `<!-- ${m} -->`,
-  // Block comment /* */
-  ".css": (m) => `/* ${m} */`,
-  ".scss": (m) => `/* ${m} */`,
-  ".less": (m) => `/* ${m} */`,
-  // SQL / Lua / Haskell --
-  ".sql": (m) => `-- ${m}`,
-  ".lua": (m) => `-- ${m}`,
-  ".hs": (m) => `-- ${m}`,
-  // Batch REM
-  ".bat": (m) => `REM ${m}`,
-  ".cmd": (m) => `REM ${m}`
-};
-function makeSafeTaskAnnotation(filePath, anchor) {
-  const ext = import_node_path3.default.extname(filePath).toLowerCase();
-  const formatter = COMMENT_FORMATS[ext];
-  if (!formatter) {
-    return null;
-  }
-  return "\n\n" + formatter(`\u2316 anchor context: #${anchor.id} ${anchor.title} (${anchor.priority.toUpperCase()})`);
-}
-function renderColdStartAnchorsContext(store, cwdOrNow, nowArg, preflightFailures) {
-  let cwd;
-  let now = Date.now();
-  if (typeof cwdOrNow === "number") {
-    now = cwdOrNow;
-  } else if (typeof cwdOrNow === "string") {
-    cwd = cwdOrNow;
-  }
-  if (typeof nowArg === "number") {
-    now = nowArg;
-  }
-  sweepStore(store, now);
-  const activeAnchors = store.list({ status: "active", cwd });
-  if (activeAnchors.length === 0) {
-    return "";
-  }
-  const lines = activeAnchors.map((a) => {
-    const fileHint = a.files.length > 0 ? ` (${a.files.slice(0, 2).join(", ")})` : "";
-    const tagHint = a.tags.length > 0 ? ` [${a.tags.join(", ")}]` : "";
-    const projHint = a.cwd ? `[${a.project}]` : "[global]";
-    let targetHint = "";
-    if (a.recurrence === "daily") {
-      targetHint = " [\u4ECA\u65E5\u5FAA\u73AF\xB7Daily]";
-    } else if (a.targetDate) {
-      const todayStr = getTodayDateString(now);
-      if (a.targetDate === todayStr) {
-        targetHint = " [\u4ECA\u65E5\u805A\u7126\xB7Due Today]";
-      } else if (a.targetDate < todayStr) {
-        targetHint = " [\u5DF2\u903E\u671F\xB7Overdue]";
-      } else {
-        targetHint = ` [\u6392\u671F:${a.targetDate}]`;
-      }
-    } else {
-      targetHint = " [\u957F\u671F\u613F\u666F\xB7Someday]";
-    }
-    const ageDays = Math.floor((now - a.createdAt) / (24 * 60 * 60 * 1e3));
-    const ageHint = ageDays > 0 ? ` (${ageDays}d old)` : "";
-    const failureSnippet = preflightFailures?.get(a.id);
-    const verifyHint = failureSnippet ? ` [\u26A1 \u7269\u7406\u9A8C\u8BC1\u5931\u8D25: ${failureSnippet.replace(/\s+/g, " ").slice(-100)}]` : a.verifyCommand ? ` [verify: ${a.verifyCommand}]` : "";
-    return `\u2022 #${a.id} ${projHint}${targetHint} [${a.priority.toUpperCase()}] ${a.title}${verifyHint}${ageHint}${tagHint}${fileHint}`;
-  });
-  return [
-    `<active-anchors count="${activeAnchors.length}">`,
-    `Unfinished cross-session commitments from previous sessions:`,
-    lines.join("\n"),
-    ``,
-    `CONVERSATIONAL PROTOCOL (HUMAN PARTNER TONE):`,
-    `- If the user opens the session with a casual greeting or continuation ("hi", "\u5728\u5417", "\u7EE7\u7EED", "\u65E9\u4E0A\u597D"), naturally prioritize items tagged [\u4ECA\u65E5\u805A\u7126\xB7Due Today] in a friendly assistant tone (e.g. "\u55E8\uFF01\u4ECA\u5929\u89C4\u5212\u7684\u3010...\u3011\u73B0\u5728\u5904\u7406\u8FD8\u662F\u770B\u522B\u7684\uFF1F").`,
-    `- If an anchor has [\u26A1 \u7269\u7406\u9A8C\u8BC1\u5931\u8D25], its verifyCommand failed on session start. Target the failing assertion directly.`,
-    `- If the user issues a direct, concrete new instruction (e.g. "\u5E2E\u6211\u67E5\u4E0B\u8FD9\u4E2A\u62A5\u9519"), DO NOT interrupt their flow. Focus directly on their instruction.`,
-    `- When a commitment is satisfied during work, automatically call anchor(action="settle", id=...) to clear it.`,
-    `</active-anchors>`
-  ].join("\n");
-}
-
-// src/settlement.ts
-var import_node_child_process = require("child_process");
-function runPhysicalVerification(anchor, cwd) {
-  if (!anchor.verifyCommand?.trim()) {
-    return { success: false, output: "No verification command specified" };
-  }
-  const targetCwd = anchor.cwd || cwd;
-  try {
-    const stdout = (0, import_node_child_process.execSync)(anchor.verifyCommand, {
-      cwd: targetCwd,
-      encoding: "utf-8",
-      timeout: 8e3,
-      maxBuffer: 4 * 1024 * 1024,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    return { success: true, output: stdout.trim() };
-  } catch (err) {
-    return { success: false, output: String(err.stderr || err.stdout || err.message).trim() };
-  }
-}
-function generateSettlementProposals(store, touchedFiles, cwd) {
-  const activeAndSleeping = store.list({ cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
-  const matches = findMatchedAnchors(activeAndSleeping, touchedFiles);
-  const proposals = [];
-  for (const match of matches) {
-    const fileList = match.matchedFiles.slice(0, 3).join(", ");
-    const moreSuffix = match.matchedFiles.length > 3 ? ` \u7B49 ${match.matchedFiles.length} \u4E2A\u6587\u4EF6` : "";
-    proposals.push({
-      anchor: match.anchor,
-      matchedFiles: match.matchedFiles,
-      reason: `\u672C\u6B21\u4F1A\u8BDD\u4FEE\u6539\u4E86 ${fileList}${moreSuffix}`,
-      recommendedAction: match.score >= 0.85 ? "settle" : "defer"
-    });
-  }
-  return proposals;
-}
-
 // src/tui.ts
-var import_node_path4 = __toESM(require("path"), 1);
-function classifyAnchor(anchor, now = Date.now()) {
-  if (anchor.recurrence === "daily") {
-    return "Habits";
-  }
-  if (!anchor.targetDate) {
-    return "Backlog";
-  }
-  const todayStr = getTodayDateString(now);
-  if (anchor.targetDate <= todayStr) {
-    return "Today";
-  }
-  return "Upcoming";
-}
-function groupAnchorsByQuadrant(anchors, now = Date.now()) {
-  const groups = {
-    today: [],
-    upcoming: [],
-    habits: [],
-    backlog: []
-  };
-  for (const a of anchors) {
-    const q = classifyAnchor(a, now);
-    if (q === "Today") groups.today.push(a);
-    else if (q === "Upcoming") groups.upcoming.push(a);
-    else if (q === "Habits") groups.habits.push(a);
-    else groups.backlog.push(a);
-  }
-  return groups;
-}
+var import_node_path2 = __toESM(require("path"), 1);
 var ANSI_REGEX = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
 function stripAnsi(str) {
   return str.replace(ANSI_REGEX, "");
@@ -1216,14 +615,12 @@ function truncateToWidth(str, maxWidth, ellipsis = "\u2026") {
     const charLen = codePoint > 65535 ? 2 : 1;
     const fullChar = singleLine.slice(i, i + charLen);
     const charWidth = getDisplayWidth(fullChar);
-    if (accumWidth + charWidth > target) {
-      break;
-    }
+    if (accumWidth + charWidth > target) break;
     accumulated += fullChar;
     accumWidth += charWidth;
     i += charLen;
   }
-  accumulated = accumulated.replace(/\s*[\(\[\{（【]$/, "");
+  accumulated = accumulated.replace(/\s*[\(\[\{（【][^)\]}）】]*$/, "");
   return accumulated + ellipsis + (singleLine.includes("\x1B") ? "\x1B[0m" : "");
 }
 function padToWidth(str, targetWidth) {
@@ -1232,76 +629,59 @@ function padToWidth(str, targetWidth) {
   if (current >= targetWidth) return truncated;
   return truncated + " ".repeat(targetWidth - current);
 }
-function formatTargetDate(anchor, now = Date.now()) {
-  if (anchor.recurrence === "daily") {
-    return "Daily";
-  }
-  if (!anchor.targetDate) {
-    return "Someday";
-  }
-  const todayStr = getTodayDateString(now);
-  if (anchor.targetDate === todayStr) {
-    return "Today";
-  }
-  const MS_DAY = 24 * 60 * 60 * 1e3;
-  const tomorrowStr = getTodayDateString(now + MS_DAY);
-  if (anchor.targetDate === tomorrowStr) {
-    return "Tomorrow";
-  }
-  const in2dStr = getTodayDateString(now + 2 * MS_DAY);
-  if (anchor.targetDate === in2dStr) {
-    return "In 2d";
-  }
-  const in3dStr = getTodayDateString(now + 3 * MS_DAY);
-  if (anchor.targetDate === in3dStr) {
-    return "In 3d";
-  }
-  if (anchor.targetDate < todayStr) {
-    return "Overdue";
-  }
-  const parts = anchor.targetDate.split("-");
-  if (parts.length === 3) {
-    return `${parts[1]}-${parts[2]}`;
-  }
-  return anchor.targetDate;
+function formatRelativeAge(timestamp, now = Date.now()) {
+  const diffSec = Math.max(0, Math.floor((now - timestamp) / 1e3));
+  if (diffSec < 60) return "just now";
+  const diffMin = Math.floor(diffSec / 60);
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHours = Math.floor(diffMin / 60);
+  if (diffHours < 24) return `${diffHours}h ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays}d ago`;
 }
-function formatCreationTime(timestamp, now = Date.now()) {
-  const d = new Date(timestamp);
-  const nowD = new Date(now);
-  const pad = (n) => String(n).padStart(2, "0");
-  const timeStr = `${pad(d.getHours())}:${pad(d.getMinutes())}`;
-  const todayStr = getTodayDateString(now);
-  const createdDayStr = getTodayDateString(timestamp);
-  if (createdDayStr === todayStr) {
-    return `Today ${timeStr}`;
-  }
-  const yesterdayStr = getTodayDateString(now - 24 * 60 * 60 * 1e3);
-  if (createdDayStr === yesterdayStr) {
-    return `Yesterday ${timeStr}`;
+function formatOrigin(anchor) {
+  if (typeof anchor === "string") {
+    if (!anchor) return "global";
+    return import_node_path2.default.basename(anchor.replace(/\\/g, "/")) || "global";
+  }
+  let proj = "global";
+  if (anchor.project && anchor.project !== "global") {
+    const normProj = anchor.project.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normProj.includes("/")) {
+      const parts = normProj.split("/").filter(Boolean);
+      proj = parts.slice(-2).join("/");
+    } else {
+      proj = normProj;
+    }
+  } else if (anchor.cwd) {
+    proj = import_node_path2.default.basename(anchor.cwd.replace(/\\/g, "/")) || "global";
   }
-  const mmdd = `${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-  if (d.getFullYear() === nowD.getFullYear()) {
-    return `${mmdd} ${timeStr}`;
+  if (anchor.files && anchor.files.length > 0) {
+    const shortFile = import_node_path2.default.basename(anchor.files[0].replace(/\\/g, "/"));
+    if (shortFile && !proj.endsWith(shortFile)) {
+      return `${proj} \xB7 ${shortFile}`;
+    }
   }
-  return `${d.getFullYear()}-${mmdd}`;
+  return proj;
 }
-function formatOrigin(anchor) {
-  if (typeof anchor === "object") {
-    if (!anchor.cwd) return anchor.project || "global";
-    return import_node_path4.default.basename(anchor.cwd) || "global";
-  }
-  if (!anchor) return "global";
-  return import_node_path4.default.basename(anchor) || "global";
+function sortAnchorsForDisplay(anchors, cwd) {
+  return [...anchors].sort((a, b) => {
+    if (a.status !== b.status) {
+      return a.status === "active" ? -1 : 1;
+    }
+    if (cwd) {
+      const aMatch = isAnchorTargetingWorkspace(a, cwd) ? 0 : 1;
+      const bMatch = isAnchorTargetingWorkspace(b, cwd) ? 0 : 1;
+      if (aMatch !== bMatch) return aMatch - bMatch;
+    }
+    return b.lastTouchedAt - a.lastTouchedAt;
+  });
 }
 function updateAnchorStatusBar(ctx, store) {
   if (!hasActiveUI(ctx)) return;
   try {
     const active = store.list({ status: "active", cwd: ctx.cwd });
-    if (active.length === 0) {
-      ctx.ui.setStatus("anchor", void 0);
-      return;
-    }
-    ctx.ui.setStatus("anchor", `\u2316 ${active.length}`);
+    ctx.ui.setStatus("anchor", active.length > 0 ? `\u2316 ${active.length}` : void 0);
   } catch {
   }
 }
@@ -1313,26 +693,30 @@ function updateStartupBanner(ctx, store) {
       ctx.ui.setWidget("anchor-startup", void 0);
       return;
     }
-    const groups = groupAnchorsByQuadrant(active);
-    const sorted = [...groups.today, ...groups.upcoming, ...groups.habits, ...groups.backlog];
+    const sorted = sortAnchorsForDisplay(active, ctx.cwd);
     const topItems = sorted.slice(0, 3);
     const factory = (_tui, theme) => ({
       render: (width) => {
-        const maxTitleWidth = Math.max(12, width - 36);
+        const maxTitleWidth = Math.max(14, width - 34);
         const fg = theme?.fg ? theme.fg.bind(theme) : (_c, text) => text;
+        const label = active.length === 1 ? "1 note" : `${active.length} notes`;
         const lines = [
-          truncateToWidth(fg("accent", `\u2316 Anchor \xB7 ${active.length} active commitments:`), width)
+          truncateToWidth(fg("accent", `\u2316 ${label}`), width)
         ];
-        for (let i = 0; i < topItems.length; i++) {
-          const a = topItems[i];
+        for (const a of topItems) {
           const num = a.id.replace(/^anc-/, "").padStart(2, "0");
-          const q = classifyAnchor(a);
-          const tgt = formatTargetDate(a);
-          const titlePadded = truncateToWidth(a.title, maxTitleWidth);
-          lines.push(truncateToWidth(`  \u2022 ${fg("muted", `[${q}]`)}  ${fg("dim", num)} ${titlePadded} ${fg("dim", `(${tgt})`)}`, width));
+          const origin = formatOrigin(a);
+          const age = formatRelativeAge(a.createdAt);
+          const titleClipped = truncateToWidth(a.title, maxTitleWidth);
+          lines.push(
+            truncateToWidth(
+              `  ${fg("dim", num)}  ${titleClipped}  ${fg("muted", `\xB7 ${origin}`)} ${fg("dim", `(${age})`)}`,
+              width
+            )
+          );
         }
         if (sorted.length > 3) {
-          lines.push(truncateToWidth(fg("dim", `  (+${sorted.length - 3} more \xB7 run /anchor to inspect)`), width));
+          lines.push(truncateToWidth(fg("dim", `  +${sorted.length - 3} more \xB7 /anchor`), width));
         }
         return lines;
       },
@@ -1346,77 +730,62 @@ function updateStartupBanner(ctx, store) {
 }
 async function openAnchorDashboard(ctx, store) {
   if (!hasActiveUI(ctx)) return;
-  const list = store.list({ status: "active", cwd: ctx.cwd });
-  if (list.length === 0) {
-    ctx.ui.notify("\u2316 No active anchors. Use /pin <task> to record.", "info");
+  const allNotes = store.list({ cwd: ctx.cwd, all: true }).filter((a) => a.status === "active" || a.status === "sleeping");
+  if (allNotes.length === 0) {
+    ctx.ui.notify("\u2316 No sticky notes. Use /pin <note> to stick one.", "info");
     return;
   }
-  const groups = groupAnchorsByQuadrant(list);
-  const sortedList = [
-    ...groups.today,
-    ...groups.upcoming,
-    ...groups.habits,
-    ...groups.backlog
-  ];
+  const sorted = sortAnchorsForDisplay(allNotes, ctx.cwd);
   const optionMap = /* @__PURE__ */ new Map();
   const displayOptions = [];
   const termCols = process.stdout?.columns || 96;
-  const isNarrow = termCols < 88;
-  const titleWidth = isNarrow ? Math.max(18, termCols - 36) : 34;
-  for (let i = 0; i < sortedList.length; i++) {
-    const a = sortedList[i];
+  const isNarrow = termCols < 84;
+  const titleWidth = isNarrow ? Math.max(20, termCols - 30) : 42;
+  for (const a of sorted) {
     const num = a.id.replace(/^anc-/, "").padStart(2, "0");
-    const category = padToWidth(`[${classifyAnchor(a)}]`, 12);
     const origin = formatOrigin(a);
-    const target = formatTargetDate(a);
-    const created = formatCreationTime(a.createdAt);
-    const titleWithFiles = a.files && a.files.length > 0 ? `${a.title} [${a.files.slice(0, 1).join(", ")}]` : a.title;
+    const age = a.status === "sleeping" ? `${formatRelativeAge(a.createdAt)} \xB7 quiet` : formatRelativeAge(a.createdAt);
     const colNum = `${num}  `;
-    const colTitle = padToWidth(titleWithFiles, titleWidth);
-    const colOrigin = padToWidth(origin, 10);
-    const colTarget = padToWidth(target, 12);
-    const colCreated = created;
-    const label = isNarrow ? `${colNum}${category}${colTitle}  ${colTarget}`.trimEnd() : `${colNum}${category}${colTitle}  ${colOrigin}  ${colTarget}  ${colCreated}`.trimEnd();
+    const colTitle = padToWidth(a.title, titleWidth);
+    const colOrigin = padToWidth(origin, 22);
+    const label = isNarrow ? `${colNum}${colTitle}  ${age}`.trimEnd() : `${colNum}${colTitle}  ${colOrigin}  ${age}`.trimEnd();
     optionMap.set(label, a);
     displayOptions.push(label);
   }
-  const selected = await ctx.ui.select("\u2316 Anchors (select to inspect or settle):", displayOptions);
+  const selected = await ctx.ui.select("\u2316 Notes (select a note):", displayOptions);
   if (!selected) return;
   const anchor = optionMap.get(selected);
   if (!anchor) return;
-  const action = await ctx.ui.select(
-    `\u2316 Anchor #${anchor.id}: "${anchor.title}"`,
-    [
-      "\u2713 Settle (Mark completed and archive)",
-      "\u2139 View details & associated files",
-      "\u21A9 Cancel"
-    ]
-  );
+  const actions = [
+    "\u2713 Done (tear off note)",
+    ...anchor.status === "sleeping" ? ["\u26A1 Wake up (mark active)"] : [],
+    "\u2139 Read full note",
+    "\u21A9 Back"
+  ];
+  const action = await ctx.ui.select(`\u2316 #${anchor.id.replace(/^anc-/, "")}: "${anchor.title}"`, actions);
   if (!action || action.startsWith("\u21A9")) return;
   if (action.startsWith("\u2713")) {
-    store.settle(anchor.id, { settledBy: "manual-command" });
-    const successMsg = anchor.recurrence === "daily" ? `\u2316 Completed for today: "${anchor.title}" (resets tomorrow)` : `\u2316 Settled #${anchor.id}: "${anchor.title}" (/anchor undo to revert)`;
-    ctx.ui.notify(successMsg, "info");
+    store.settle(anchor.id, { settledBy: "manual" });
+    ctx.ui.notify(`\u2316 Torn off #${anchor.id.replace(/^anc-/, "")}: "${anchor.title}" (/anchor undo to put back)`, "info");
+    updateAnchorStatusBar(ctx, store);
+  } else if (action.startsWith("\u26A1")) {
+    store.touch(anchor.id);
+    ctx.ui.notify(`\u2316 Woke up #${anchor.id.replace(/^anc-/, "")}: "${anchor.title}"`, "info");
     updateAnchorStatusBar(ctx, store);
   } else if (action.startsWith("\u2139")) {
     const details = [
-      `#${anchor.id} [${anchor.priority.toUpperCase()}] ${anchor.title}`,
-      anchor.description ? `Description: ${anchor.description}` : null,
-      anchor.targetDate ? `Target Date: ${anchor.targetDate} (${formatTargetDate(anchor)})` : null,
-      anchor.files && anchor.files.length > 0 ? `Files: ${anchor.files.join(", ")}` : null,
-      anchor.verifyCommand ? `Verify Command: ${anchor.verifyCommand}` : null,
-      `Created: ${formatCreationTime(anchor.createdAt)} (in ${anchor.project || "global"})`
+      `\u2316 Note #${anchor.id.replace(/^anc-/, "")}: ${anchor.title}`,
+      anchor.description ? `Details: ${anchor.description}` : null,
+      anchor.files.length > 0 ? `Files: ${anchor.files.join(", ")}` : null,
+      `Workspace: ${anchor.project || "global"} \xB7 Pinned ${formatRelativeAge(anchor.createdAt)}`
     ].filter(Boolean).join("\n");
     ctx.ui.notify(details, "info");
   }
 }
 
 // src/extension.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var MUTATION_TOOLS2 = /* @__PURE__ */ new Set(["edit", "write", "patch", "apply_diff", "create_file", "modify"]);
-function parseAnchorCommandInput(raw, now = Date.now()) {
+var MUTATION_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "patch", "apply_diff", "create_file", "modify"]);
+function parseAnchorCommandInput(raw) {
   const trimmed = (raw || "").trim();
   if (!trimmed || trimmed === "list" || trimmed === "ls") {
     return { mode: "dashboard" };
@@ -1431,85 +800,32 @@ function parseAnchorCommandInput(raw, now = Date.now()) {
       targetId: settleMatch[1].trim().replace(/^#/, "")
     };
   }
-  let targetDate;
-  const tokens = trimmed.split(/\s+/);
-  const dueIdx = tokens.findIndex((t) => t === "--due" || t === "-d");
-  if (dueIdx !== -1 && tokens[dueIdx + 1]) {
-    const rawDue = tokens[dueIdx + 1];
-    targetDate = detectTargetDate(rawDue, now) || rawDue;
-    tokens.splice(dueIdx, 2);
-  }
-  const cleanTitle = tokens.join(" ").trim();
   return {
     mode: "pin",
-    title: cleanTitle || trimmed,
-    targetDate
+    title: trimmed
   };
 }
 function resolveAnchorTarget(store, idOrIndex, cwd) {
   const clean = idOrIndex.trim().replace(/^#/, "");
   if (/^\d+$/.test(clean)) {
     const seqIndex = parseInt(clean, 10);
-    const active = store.list({ status: "active", cwd });
-    const groups = groupAnchorsByQuadrant(active);
-    const sortedActive = [
-      ...groups.today,
-      ...groups.upcoming,
-      ...groups.habits,
-      ...groups.backlog
-    ];
-    if (seqIndex >= 1 && seqIndex <= sortedActive.length) {
-      return sortedActive[seqIndex - 1].id;
+    const visible = store.list({ cwd, all: true }).filter((a) => a.status === "active" || a.status === "sleeping");
+    const sorted = sortAnchorsForDisplay(visible, cwd);
+    if (seqIndex >= 1 && seqIndex <= sorted.length) {
+      return sorted[seqIndex - 1].id;
     }
   }
-  const direct = store.get(clean);
-  return direct?.id;
+  return store.get(clean)?.id;
 }
 function extension_default(pi) {
   const store = new AnchorStore();
-  const observer = new SessionTouchObserver();
   const annotatedThisSession = /* @__PURE__ */ new Set();
-  const preflightFailures = /* @__PURE__ */ new Map();
   pi.on("session_start", async (event, ctx) => {
-    observer.clear();
     annotatedThisSession.clear();
-    preflightFailures.clear();
-    const sweep = sweepStore(store);
-    if (sweep.transitionedToSleeping.length > 0) {
-      ctx.ui.notify(`\u2316 Anchor: ${sweep.transitionedToSleeping.length} inactive tasks transitioned to sleep`, "info");
-    }
-    const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
-    for (const a of activeAnchors) {
-      if (a.verifyCommand && (!a.cwd || isSameOrSubPath(a.cwd, ctx.cwd))) {
-        try {
-          const res = runPhysicalVerification(a, ctx.cwd);
-          if (res.success) {
-            store.settle(a.id, {
-              settledBy: "verification-test",
-              summary: `Physical pre-flight test passed: ${a.verifyCommand}`
-            });
-            ctx.ui.notify(`\u2316 Verification passed! Auto-settled #${a.id}: "${a.title}"`, "info");
-          } else {
-            preflightFailures.set(a.id, res.output.slice(-250));
-          }
-        } catch (_) {
-        }
-      }
-    }
-    try {
-      const home = process.env.HOME || process.env.USERPROFILE || "";
-      const pendingPath = import_node_path5.default.join(home, ".anchor", "pending_exit.json");
-      if (import_node_fs3.default.existsSync(pendingPath)) {
-        const pending = JSON.parse(import_node_fs3.default.readFileSync(pendingPath, "utf-8"));
-        const isExpired = Date.now() - pending.timestamp >= 24 * 60 * 60 * 1e3;
-        if (!isExpired && isSameOrSubPath(pending.cwd, ctx.cwd)) {
-          ctx.ui.notify(`\u2316 [Exit Guard] Detected ${pending.modifiedCount} uncommitted changes from previous session exit. Run /pin to record.`, "info");
-          import_node_fs3.default.unlinkSync(pendingPath);
-        } else if (isExpired) {
-          import_node_fs3.default.unlinkSync(pendingPath);
-        }
-      }
-    } catch (_) {
+    sweepQuietNotes(store);
+    const quietForHere = store.list({ status: "sleeping", all: true }).filter((a) => (a.files.length > 0 || a.project && a.project !== "global" || a.cwd) && isAnchorTargetingWorkspace(a, ctx.cwd));
+    for (const q of quietForHere) {
+      store.touch(q.id);
     }
     updateAnchorStatusBar(ctx, store);
     if (event.reason !== "resume") {
@@ -1532,151 +848,75 @@ function extension_default(pi) {
   pi.on("before_agent_start", async (event, ctx) => {
     const entries = ctx.sessionManager?.getEntries() || [];
     const messageTurns = entries.filter((e) => e.type === "message");
-    const isColdStart = messageTurns.length <= 1;
-    if (isColdStart) {
-      const contextSnippet = renderColdStartAnchorsContext(store, ctx.cwd, void 0, preflightFailures);
-      if (contextSnippet) {
-        return {
-          systemPrompt: `${event.systemPrompt}
+    if (messageTurns.length <= 1) {
+      const snippet = renderColdStartAnchorsContext(store, ctx.cwd);
+      if (snippet) {
+        return { systemPrompt: `${event.systemPrompt}
 
-${contextSnippet}`
-        };
+${snippet}` };
       }
     }
   });
   pi.on("tool_result", async (event, ctx) => {
-    if (!event.isError) {
-      observer.recordToolCall(event.toolName, event.input || {});
-    }
-    const pathInput = event.input?.path;
-    if (typeof pathInput !== "string") return;
-    const touchedPath = normalizePath(pathInput, ctx.cwd);
-    const anchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
-    const matches = findMatchedAnchors(anchors, [touchedPath]);
-    if (matches.length > 0) {
-      const isMutation = MUTATION_TOOLS2.has((event.toolName || "").toLowerCase());
-      if (isMutation && !event.isError) {
-        for (const m of matches) {
-          store.touch(m.anchor.id);
-        }
-        updateAnchorStatusBar(ctx, store);
-      }
-      const a = matches[0].anchor;
-      if (!annotatedThisSession.has(a.id)) {
-        annotatedThisSession.add(a.id);
-        const alert = makeSafeTaskAnnotation(touchedPath, a);
-        if (alert) {
-          const contents = [...event.content || []];
-          for (let i = contents.length - 1; i >= 0; i--) {
-            const item = contents[i];
-            if (item && item.type === "text") {
-              contents[i] = { ...item, text: item.text + alert };
-              return { content: contents };
+    if (event.isError) return;
+    const lowerTool = String(event.toolName || "").toLowerCase();
+    if (lowerTool === "bash" || lowerTool === "powershell") {
+      const cmd = String(event.input?.command || "");
+      if (cmd.includes("git commit")) {
+        const msgMatch = cmd.match(/-m\s+["']([^"']+)["']/);
+        if (msgMatch && msgMatch[1]) {
+          const commitMsg = msgMatch[1];
+          const candidates = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
+          for (const a of candidates) {
+            if (matchesCommitMessage(a, [commitMsg]).matched && isAnchorTargetingWorkspace(a, ctx.cwd)) {
+              store.settle(a.id, { settledBy: "commit", summary: commitMsg });
+              updateAnchorStatusBar(ctx, store);
+              if (hasActiveUI(ctx)) {
+                try {
+                  ctx.ui.notify(`\u2316 Auto-torn off #${a.id.replace(/^anc-/, "")} ("${a.title}") on git commit`, "info");
+                } catch {
+                }
+              }
             }
           }
         }
       }
     }
-  });
-  pi.on("session_shutdown", async (event, ctx) => {
-    let gitStatus = "";
-    try {
-      gitStatus = (0, import_node_child_process2.execSync)("git status --porcelain", {
-        cwd: ctx.cwd,
-        encoding: "utf-8",
-        timeout: 2e3,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).replace(/[\r\n]+$/, "");
-      const changed = gitStatus.split(/\r?\n/).filter(Boolean).map((l) => l.slice(3).replace(/^"(.*)"$/, "$1").trim()).filter(Boolean);
-      for (const f of changed) {
-        observer.addTouchedFile(f);
-      }
-    } catch {
-    }
-    if (event?.reason === "quit" && gitStatus) {
-      try {
-        const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
-        if (activeAnchors.length === 0) {
-          const home = process.env.HOME || process.env.USERPROFILE || "";
-          const pendingPath = import_node_path5.default.join(home, ".anchor", "pending_exit.json");
-          const data = {
-            cwd: ctx.cwd,
-            timestamp: Date.now(),
-            modifiedCount: gitStatus.split("\n").filter(Boolean).length
-          };
-          import_node_fs3.default.writeFileSync(pendingPath, JSON.stringify(data, null, 2), "utf-8");
-        }
-      } catch {
-      }
+    const pathInput = event.input?.path;
+    if (typeof pathInput !== "string") return;
+    const touchedPath = normalizePath(pathInput, ctx.cwd);
+    const notes = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
+    const matches = findMatchedAnchors(notes, [touchedPath]);
+    if (matches.length === 0) return;
+    if (MUTATION_TOOLS.has(lowerTool)) {
+      for (const m of matches) store.touch(m.anchor.id);
+      updateAnchorStatusBar(ctx, store);
     }
-    const modified = observer.getModifiedFiles();
-    if (modified.length === 0) return;
-    const proposals = generateSettlementProposals(store, modified, ctx.cwd);
-    if (proposals.length === 0) return;
-    for (const prop of proposals) {
-      const a = prop.anchor;
-      const commitMatch = observer.matchesCommit(a);
-      if (commitMatch.matched) {
-        store.settle(a.id, {
-          settledBy: "verification-test",
-          summary: `Auto-settled via Git commit: ${commitMatch.message}`,
-          touchedFiles: prop.matchedFiles
-        });
-        if (hasActiveUI(ctx)) {
-          try {
-            ctx.ui.notify(`\u2316 Auto-settled #${a.id} via Git commit (run /anchor undo to revert)`, "info");
-          } catch {
+    const targetNote = matches[0].anchor;
+    if (!annotatedThisSession.has(targetNote.id)) {
+      annotatedThisSession.add(targetNote.id);
+      const whisper = makeSafeTaskAnnotation(touchedPath, targetNote);
+      if (whisper) {
+        const contents = [...event.content || []];
+        for (let i = contents.length - 1; i >= 0; i--) {
+          const item = contents[i];
+          if (item && item.type === "text") {
+            contents[i] = { ...item, text: item.text + whisper };
+            return { content: contents };
           }
         }
-        continue;
-      }
-      if (a.verifyCommand) {
-        const verifyRes = runPhysicalVerification(a, ctx.cwd);
-        if (verifyRes.success) {
-          store.settle(a.id, {
-            settledBy: "verification-test",
-            summary: `Automated test passed: ${a.verifyCommand}`,
-            touchedFiles: prop.matchedFiles
-          });
-          if (hasActiveUI(ctx)) {
-            try {
-              ctx.ui.notify(`\u2316 Test passed (${a.verifyCommand}), auto-settled #${a.id}`, "info");
-            } catch {
-            }
-          }
-          continue;
-        }
-      }
-      if (!hasActiveUI(ctx)) continue;
-      try {
-        const ok = await ctx.ui.confirm(
-          "\u2316 Settle Anchor Task",
-          `Task #${a.id} [${a.title}] touched files (${prop.matchedFiles.slice(0, 2).join(", ")}).
-Mark as completed and archive?`
-        );
-        if (ok) {
-          store.settle(a.id, {
-            settledBy: "one-tap-settlement",
-            touchedFiles: prop.matchedFiles
-          });
-          ctx.ui.notify(`\u2316 Settled #${a.id}: "${a.title}"`, "info");
-        }
-      } catch {
       }
     }
   });
   pi.registerTool({
     name: "anchor",
-    label: "Anchor (Cross-session Task Protocol)",
-    description: "Manage cross-session persistent tasks that survive terminal restarts and auto-evict upon code changes or settlement. Use when the user asks to retain, pin, remember, or track a multi-session goal across sessions, or when an ongoing commitment must not be forgotten. Actions: pin (create new cross-session anchor), list (view active and sleeping anchors), settle (close and archive a completed anchor), touch (refresh activity), sweep (run decay cleanup). Stored in ~/.anchor/ with zero project repository pollution.",
-    promptSnippet: "Anchor cross-session task contracts that survive terminal restarts and auto-evict",
+    label: "Anchor (Sticky Note)",
+    description: "Pin, list, or tear off cross-session sticky notes stored in ~/.anchor/ (zero git repo clutter). Actions: pin (stick a new note), list (view notes), settle (tear off completed note).",
+    promptSnippet: "Pin or tear off cross-session sticky notes that survive terminal restarts",
     promptGuidelines: [
-      'Use `anchor` when the user asks to retain a goal across sessions or record a reminder for later/tonight/tomorrow (e.g. "\u665A\u4E0A\u6E05\u7406\u5783\u573E", "\u660E\u5929\u4F18\u5316X", "\u4FDD\u7559\u4EFB\u52A1\u76F4\u5230\u5B8C\u6210").',
-      "BOUNDARY WITH TODO: `todo` is strictly for intra-session active work breakdown (step 1, step 2, step 3 right now). For future reminders or cross-session goals, ONLY use `anchor`. NEVER duplicate a cross-session reminder into both `todo` and `anchor`.",
-      "DO NOT over-engineer or assume automated scheduled tasks unless the user explicitly requests Windows Task Scheduler or cron.",
-      "Tasks are automatically scoped to the current project context without cluttering the project git repository.",
-      'When code for an anchor is completed and verified, call `anchor` with action "settle" to archive it and free context.',
-      "Active anchors are automatically injected into future sessions in an ultra-compact block."
+      'Use `anchor` when the user asks to remember something for later/tomorrow or across sessions (e.g. "\u8BB0\u4E00\u4E0B\u660E\u5929\u91CD\u6784\u9274\u6743", "\u665A\u4E0A\u6E05\u7406\u7F13\u5B58").',
+      "BOUNDARY WITH TODO: `todo` is for multi-step work right now in this session; `anchor` is a sticky note for future sessions.",
+      'When a pinned note is completed, call `anchor` with action "settle" to tear it off.'
     ],
     parameters: import_typebox.Type.Object({
       action: import_typebox.Type.Union([
@@ -1686,29 +926,19 @@ Mark as completed and archive?`
         import_typebox.Type.Literal("touch"),
         import_typebox.Type.Literal("sweep")
       ]),
-      title: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Short imperative task title (for pin)" })),
-      description: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Detailed context, acceptance criteria, or technical notes" })),
-      priority: import_typebox.Type.Optional(import_typebox.Type.Union([import_typebox.Type.Literal("p0"), import_typebox.Type.Literal("p1"), import_typebox.Type.Literal("p2")])),
-      project: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Target project name or workspace (defaults to current directory if omitted)" })),
-      targetDate: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Expected completion date (e.g. YYYY-MM-DD, today, tomorrow)" })),
-      files: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Associated file paths or directory prefixes" })),
-      tags: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Domain tags" })),
-      verifyCommand: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Optional shell command for automated physical verification" })),
-      id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Anchor ID, e.g. anc-1 (for settle or touch)" }))
+      title: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Sticky note text (for pin)" })),
+      description: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Optional extra details" })),
+      project: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Optional project name or folder" })),
+      files: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Optional associated file paths" })),
+      id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Note ID, e.g. anc-1 or 1 (for settle)" }))
     }),
     renderCall(args, theme) {
       const action = args.action || "list";
       let title = theme.fg("toolTitle", theme.bold("\u2316 anchor ")) + theme.fg("accent", action);
       if (action === "pin" && args.title) {
-        const due = args.targetDate ? ` ${theme.fg("dim", `[${args.targetDate}]`)}` : "";
-        const files = args.files && args.files.length > 0 ? ` ${theme.fg("muted", `(${args.files.slice(0, 2).join(", ")})`)}` : "";
-        title += ` "${args.title}"${due}${files}`;
-      } else if (action === "settle" && args.id) {
-        title += ` ${theme.fg("dim", `#${args.id}`)}`;
-      } else if (action === "touch" && args.id) {
-        title += ` ${theme.fg("dim", `#${args.id}`)}`;
-      } else if (action === "list") {
-        if (args.priority) title += ` ${theme.fg("muted", `[${args.priority}]`)}`;
+        title += ` "${args.title}"`;
+      } else if ((action === "settle" || action === "touch") && args.id) {
+        title += ` ${theme.fg("dim", `#${String(args.id).replace(/^anc-/, "")}`)}`;
       }
       return {
         render: (width) => [truncateToWidth(title, width)],
@@ -1717,17 +947,11 @@ Mark as completed and archive?`
       };
     },
     renderResult(result, _options, theme) {
-      if (result.isError) {
-        const errText = result.content?.[0]?.text || "Execution failed";
-        return {
-          render: (width) => [truncateToWidth(theme.fg("error", `\u2717 ${errText}`), width)],
-          invalidate: () => {
-          }
-        };
-      }
-      const text = result.content?.[0]?.text || "OK";
+      const text = result.content?.[0]?.text || (result.isError ? "Failed" : "OK");
+      const color = result.isError ? "error" : "success";
+      const icon = result.isError ? "\u2717" : "\u2714";
       return {
-        render: (width) => [truncateToWidth(theme.fg("success", `\u2714 ${text}`), width)],
+        render: (width) => [truncateToWidth(theme.fg(color, `${icon} ${text}`), width)],
         invalidate: () => {
         }
       };
@@ -1736,91 +960,63 @@ Mark as completed and archive?`
       if (!ctx) return { content: [{ type: "text", text: "Error: context required" }], isError: true };
       if (params.action === "pin") {
         if (!params.title) {
-          return { content: [{ type: "text", text: "Error: title is required for pin action" }], isError: true };
+          return { content: [{ type: "text", text: "Error: title is required for pin" }], isError: true };
         }
         const anc = store.create({
           title: params.title,
           description: params.description,
-          priority: params.priority || "p1",
           project: params.project,
-          targetDate: params.targetDate,
           cwd: ctx.cwd,
-          files: params.files || [],
-          tags: params.tags || [],
-          verifyCommand: params.verifyCommand
+          files: params.files || []
         });
         updateAnchorStatusBar(ctx, store);
         return {
-          content: [{
-            type: "text",
-            text: `Successfully anchored task #${anc.id}: "${anc.title}" [${anc.project}]. Stored in ~/.anchor/.`
-          }],
+          content: [{ type: "text", text: `Pinned note #${anc.id.replace(/^anc-/, "")}: "${anc.title}"` }],
           isError: false
         };
       }
       if (params.action === "list") {
-        const active = store.list({ status: "active", cwd: ctx.cwd });
-        const sleeping = store.list({ status: "sleeping", cwd: ctx.cwd });
+        const notes = store.list({ cwd: ctx.cwd, all: true }).filter((a) => a.status === "active" || a.status === "sleeping");
         return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({ active, sleeping }, null, 2)
-          }],
+          content: [{ type: "text", text: JSON.stringify(notes, null, 2) }],
           isError: false
         };
       }
       if (params.action === "settle") {
         if (!params.id) {
-          return { content: [{ type: "text", text: "Error: id is required for settle action" }], isError: true };
+          return { content: [{ type: "text", text: "Error: id is required for settle" }], isError: true };
         }
         try {
-          const settled = store.settle(params.id, { settledBy: "verification-test" });
+          const targetId = resolveAnchorTarget(store, String(params.id), ctx.cwd) || String(params.id);
+          const settled = store.settle(targetId, { settledBy: "manual" });
           updateAnchorStatusBar(ctx, store);
           return {
-            content: [{
-              type: "text",
-              text: `Anchor #${settled.id} successfully settled and evicted from active context.`
-            }],
+            content: [{ type: "text", text: `Torn off note #${settled.id.replace(/^anc-/, "")}: "${settled.title}"` }],
             isError: false
           };
         } catch (err) {
           return { content: [{ type: "text", text: err.message }], isError: true };
         }
       }
-      if (params.action === "touch") {
-        if (!params.id) {
-          return { content: [{ type: "text", text: "Error: id is required for touch action" }], isError: true };
-        }
+      if (params.action === "touch" && params.id) {
         try {
-          const touched = store.touch(params.id);
+          const touched = store.touch(String(params.id));
           updateAnchorStatusBar(ctx, store);
-          return {
-            content: [{
-              type: "text",
-              text: `Anchor #${touched.id} touched and decay timer refreshed.`
-            }],
-            isError: false
-          };
+          return { content: [{ type: "text", text: `Refreshed note #${touched.id}` }], isError: false };
         } catch (err) {
           return { content: [{ type: "text", text: err.message }], isError: true };
         }
       }
       if (params.action === "sweep") {
-        const res = sweepStore(store);
+        const res = sweepQuietNotes(store);
         updateAnchorStatusBar(ctx, store);
-        return {
-          content: [{
-            type: "text",
-            text: `Sweep complete: ${res.transitionedToSleeping.length} sleeping, ${res.evictedToGraveyard.length} evicted to graveyard.`
-          }],
-          isError: false
-        };
+        return { content: [{ type: "text", text: `Quieted ${res.quieted.length} old note(s).` }], isError: false };
       }
       return { content: [{ type: "text", text: "Unknown action" }], isError: true };
     }
   });
   pi.registerCommand("anchor", {
-    description: "Inspect, pin, or settle active anchors (e.g. /anchor, /anchor done 1, /anchor undo)",
+    description: "View, pin, or tear off sticky notes (/anchor, /anchor done 1, /anchor undo)",
     handler: async (args, ctx) => {
       const parsed = parseAnchorCommandInput(args);
       if (parsed.mode === "dashboard") {
@@ -1830,21 +1026,21 @@ Mark as completed and archive?`
       if (parsed.mode === "undo") {
         try {
           const restored = store.undoSettle();
-          ctx.ui.notify(`\u2316 Restored #${restored.id}: "${restored.title}"`, "info");
+          ctx.ui.notify(`\u2316 Put back #${restored.id.replace(/^anc-/, "")}: "${restored.title}"`, "info");
           updateAnchorStatusBar(ctx, store);
         } catch (err) {
-          ctx.ui.notify(`Revert failed: ${err.message}`, "error");
+          ctx.ui.notify(`Undo failed: ${err.message}`, "error");
         }
         return;
       }
       if (parsed.mode === "settle" && parsed.targetId) {
         const resolvedId = resolveAnchorTarget(store, parsed.targetId, ctx.cwd);
         if (!resolvedId) {
-          ctx.ui.notify(`\u2316 Anchor not found: ${parsed.targetId}`, "error");
+          ctx.ui.notify(`\u2316 Note not found: ${parsed.targetId}`, "error");
           return;
         }
-        const settled = store.settle(resolvedId, { settledBy: "manual-command" });
-        ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
+        const settled = store.settle(resolvedId, { settledBy: "manual" });
+        ctx.ui.notify(`\u2316 Torn off #${settled.id.replace(/^anc-/, "")}: "${settled.title}" (/anchor undo to put back)`, "info");
         updateAnchorStatusBar(ctx, store);
         return;
       }
@@ -1852,40 +1048,32 @@ Mark as completed and archive?`
       if (/^(?:#?anc-\d+|#\d+)$/i.test(rawTrimmed)) {
         const resolvedId = resolveAnchorTarget(store, rawTrimmed, ctx.cwd);
         if (resolvedId) {
-          const settled = store.settle(resolvedId, { settledBy: "manual-command" });
-          ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
+          const settled = store.settle(resolvedId, { settledBy: "manual" });
+          ctx.ui.notify(`\u2316 Torn off #${settled.id.replace(/^anc-/, "")}: "${settled.title}" (/anchor undo to put back)`, "info");
           updateAnchorStatusBar(ctx, store);
           return;
         }
       }
-      const anc = store.create({
-        title: parsed.title || rawTrimmed,
-        targetDate: parsed.targetDate,
-        cwd: ctx.cwd
-      });
-      ctx.ui.notify(`\u2316 Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ""}`, "info");
+      const anc = store.create({ title: parsed.title || rawTrimmed, cwd: ctx.cwd });
+      ctx.ui.notify(`\u2316 Pinned #${anc.id.replace(/^anc-/, "")}: "${anc.title}"`, "info");
       updateAnchorStatusBar(ctx, store);
     }
   });
   pi.registerCommand("pin", {
-    description: "Pin a task across sessions (e.g. /pin Refactor auth --due tomorrow)",
+    description: "Stick a quick note across sessions (e.g. /pin Check auth token expiry)",
     handler: async (args, ctx) => {
-      const parsed = parseAnchorCommandInput(args);
-      if (parsed.mode === "dashboard" || !parsed.title) {
+      const text = (args || "").trim();
+      if (!text) {
         await openAnchorDashboard(ctx, store);
         return;
       }
-      const anc = store.create({
-        title: parsed.title,
-        targetDate: parsed.targetDate,
-        cwd: ctx.cwd
-      });
-      ctx.ui.notify(`\u2316 Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ""}`, "info");
+      const anc = store.create({ title: text, cwd: ctx.cwd });
+      ctx.ui.notify(`\u2316 Pinned #${anc.id.replace(/^anc-/, "")}: "${anc.title}"`, "info");
       updateAnchorStatusBar(ctx, store);
     }
   });
   pi.registerCommand("done", {
-    description: "Complete an active anchor by row number or ID (e.g. /done 1)",
+    description: "Tear off a sticky note by number or ID (e.g. /done 1)",
     handler: async (args, ctx) => {
       const target = (args || "").trim();
       if (!target) {
@@ -1894,16 +1082,16 @@ Mark as completed and archive?`
       }
       const resolvedId = resolveAnchorTarget(store, target, ctx.cwd);
       if (!resolvedId) {
-        ctx.ui.notify(`\u2316 Anchor not found: ${target}`, "error");
+        ctx.ui.notify(`\u2316 Note not found: ${target}`, "error");
         return;
       }
-      const settled = store.settle(resolvedId, { settledBy: "manual-command" });
-      ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
+      const settled = store.settle(resolvedId, { settledBy: "manual" });
+      ctx.ui.notify(`\u2316 Torn off #${settled.id.replace(/^anc-/, "")}: "${settled.title}" (/anchor undo to put back)`, "info");
       updateAnchorStatusBar(ctx, store);
     }
   });
   pi.registerCommand("anchors", {
-    description: "Inspect and settle active anchors",
+    description: "View sticky notes",
     handler: async (_args, ctx) => {
       await openAnchorDashboard(ctx, store);
     }