pi-anchor 0.2.3 → 0.3.0

package/dist/extension.js

@@ -1,20 +1,24 @@
 import {
   AnchorStore,
   SessionTouchObserver,
+  detectTargetDate,
   findMatchedAnchors,
   generateSettlementProposals,
   hasActiveUI,
+  isAnchorTargetingWorkspace,
   isSameOrSubPath,
   makeSafeTaskAnnotation,
   normalizePath,
   openAnchorDashboard,
   renderColdStartAnchorsContext,
   runPhysicalVerification,
+  sortAnchorsForDisplay,
   sweepStore,
   truncateToWidth,
+  tryRealtimeAutoSettle,
   updateAnchorStatusBar,
   updateStartupBanner
-} from "./chunk-G72UHPBN.js";
+} from "./chunk-Q7IILJFA.js";
 
 // src/extension.ts
 import { Type } from "@sinclair/typebox";
@@ -22,6 +26,49 @@ import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 var MUTATION_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "patch", "apply_diff", "create_file", "modify"]);
+function parseAnchorCommandInput(raw, now = Date.now()) {
+  const trimmed = (raw || "").trim();
+  if (!trimmed || trimmed === "list" || trimmed === "ls") {
+    return { mode: "dashboard" };
+  }
+  if (trimmed === "undo") {
+    return { mode: "undo" };
+  }
+  const settleMatch = trimmed.match(/^(?:done|rm|close|settle)\s+(.+)$/i);
+  if (settleMatch) {
+    return {
+      mode: "settle",
+      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
+  };
+}
+function resolveAnchorTarget(store, idOrIndex, cwd) {
+  const clean = idOrIndex.trim().replace(/^#/, "");
+  if (/^\d+$/.test(clean)) {
+    const seqIndex = parseInt(clean, 10);
+    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;
+}
 function extension_default(pi) {
   const store = new AnchorStore();
   const observer = new SessionTouchObserver();
@@ -32,8 +79,12 @@ function extension_default(pi) {
     annotatedThisSession.clear();
     preflightFailures.clear();
     const sweep = sweepStore(store);
-    if (sweep.transitionedToSleeping.length > 0) {
-      ctx.ui.notify(`Anchor: ${sweep.transitionedToSleeping.length} \u4E2A\u975E\u6D3B\u8DC3\u4EFB\u52A1\u5DF2\u8FDB\u5165\u4F11\u7720`, "info");
+    const sleepingForWorkspace = 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 sa of sleepingForWorkspace) {
+      store.touch(sa.id);
+    }
+    if (sweep.transitionedToSleeping.length > 0 && sleepingForWorkspace.length === 0) {
+      ctx.ui.notify(`\u2316 Anchor: ${sweep.transitionedToSleeping.length} inactive task(s) moved to quiet mode (/anchor to view)`, "info");
     }
     const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
     for (const a of activeAnchors) {
@@ -45,7 +96,7 @@ function extension_default(pi) {
               settledBy: "verification-test",
               summary: `Physical pre-flight test passed: ${a.verifyCommand}`
             });
-            ctx.ui.notify(`\u2693 \u7269\u7406\u9A8C\u8BC1\u901A\u8FC7\uFF01\u951A\u70B9 #${a.id} ("${a.title}") \u5DF2\u81EA\u52A8\u7ED3\u6848\u5F52\u6863\u3002`, "info");
+            ctx.ui.notify(`\u2316 Verification passed! Auto-settled #${a.id}: "${a.title}"`, "info");
           } else {
             preflightFailures.set(a.id, res.output.slice(-250));
           }
@@ -102,8 +153,26 @@ ${contextSnippet}`
     }
   });
   pi.on("tool_result", async (event, ctx) => {
+    const lowerTool = String(event.toolName || "").toLowerCase();
     if (!event.isError) {
       observer.recordToolCall(event.toolName, event.input || {});
+      if (lowerTool === "bash" || lowerTool === "powershell") {
+        const executedCmd = String(event.input?.command || "");
+        if (executedCmd.includes("git commit") || executedCmd.length > 0) {
+          const settledNow = tryRealtimeAutoSettle(store, observer, ctx.cwd, executedCmd);
+          if (settledNow.length > 0) {
+            updateAnchorStatusBar(ctx, store);
+            if (hasActiveUI(ctx)) {
+              for (const item of settledNow) {
+                try {
+                  ctx.ui.notify(`\u2316 Auto-settled #${item.anchor.id} ("${item.anchor.title}") via ${item.reason}`, "info");
+                } catch {
+                }
+              }
+            }
+          }
+        }
+      }
     }
     const pathInput = event.input?.path;
     if (typeof pathInput !== "string") return;
@@ -167,8 +236,8 @@ ${contextSnippet}`
       }
     }
     const modified = observer.getModifiedFiles();
-    if (modified.length === 0) return;
-    const proposals = generateSettlementProposals(store, modified, ctx.cwd);
+    if (modified.length === 0 && !observer.hasCommitted()) return;
+    const proposals = generateSettlementProposals(store, modified, ctx.cwd, observer);
     if (proposals.length === 0) return;
     for (const prop of proposals) {
       const a = prop.anchor;
@@ -377,14 +446,14 @@ Mark as completed and archive?`
     }
   });
   pi.registerCommand("anchor", {
-    description: "Inspect and settle active anchors",
+    description: "Inspect, pin, or settle active anchors (e.g. /anchor, /anchor done 1, /anchor undo)",
     handler: async (args, ctx) => {
-      const input = (args || "").trim();
-      if (!input || input === "list" || input === "ls") {
+      const parsed = parseAnchorCommandInput(args);
+      if (parsed.mode === "dashboard") {
         await openAnchorDashboard(ctx, store);
         return;
       }
-      if (input === "undo") {
+      if (parsed.mode === "undo") {
         try {
           const restored = store.undoSettle();
           ctx.ui.notify(`\u2316 Restored #${restored.id}: "${restored.title}"`, "info");
@@ -394,29 +463,68 @@ Mark as completed and archive?`
         }
         return;
       }
-      const targetId = input.startsWith("#") ? input.slice(1) : input;
-      const item = store.get(targetId);
-      if (item) {
-        store.settle(targetId, { settledBy: "manual-command" });
-        ctx.ui.notify(`\u2316 Settled: "${item.title}"`, "info");
+      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");
+          return;
+        }
+        const settled = store.settle(resolvedId, { settledBy: "manual-command" });
+        ctx.ui.notify(`\u2316 Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, "info");
         updateAnchorStatusBar(ctx, store);
         return;
       }
-      const anc = store.create({ title: input, cwd: ctx.cwd });
-      ctx.ui.notify(`\u2316 Pinned #${anc.id}: "${anc.title}"`, "info");
+      const rawTrimmed = (args || "").trim();
+      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");
+          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");
       updateAnchorStatusBar(ctx, store);
     }
   });
   pi.registerCommand("pin", {
-    description: "Quickly pin a task across sessions",
+    description: "Pin a task across sessions (e.g. /pin Refactor auth --due tomorrow)",
     handler: async (args, ctx) => {
-      const title = (args || "").trim();
-      if (!title) {
+      const parsed = parseAnchorCommandInput(args);
+      if (parsed.mode === "dashboard" || !parsed.title) {
         await openAnchorDashboard(ctx, store);
         return;
       }
-      const anc = store.create({ title, cwd: ctx.cwd });
-      ctx.ui.notify(`\u2316 Pinned #${anc.id}: "${anc.title}"`, "info");
+      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");
+      updateAnchorStatusBar(ctx, store);
+    }
+  });
+  pi.registerCommand("done", {
+    description: "Complete an active anchor by row number or ID (e.g. /done 1)",
+    handler: async (args, ctx) => {
+      const target = (args || "").trim();
+      if (!target) {
+        await openAnchorDashboard(ctx, store);
+        return;
+      }
+      const resolvedId = resolveAnchorTarget(store, target, ctx.cwd);
+      if (!resolvedId) {
+        ctx.ui.notify(`\u2316 Anchor 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");
       updateAnchorStatusBar(ctx, store);
     }
   });
@@ -428,5 +536,7 @@ Mark as completed and archive?`
   });
 }
 export {
-  extension_default as default
+  extension_default as default,
+  parseAnchorCommandInput,
+  resolveAnchorTarget
 };

package/dist/index.cjs

@@ -44,6 +44,7 @@ __export(index_exports, {
   detectRecurrence: () => detectRecurrence,
   detectTargetDate: () => detectTargetDate,
   evaluateAnchorDecay: () => evaluateAnchorDecay,
+  extractPathsFromText: () => extractPathsFromText,
   findMatchedAnchors: () => findMatchedAnchors,
   formatCreationTime: () => formatCreationTime,
   formatOrigin: () => formatOrigin,
@@ -59,6 +60,7 @@ __export(index_exports, {
   globToRegExp: () => globToRegExp,
   groupAnchorsByQuadrant: () => groupAnchorsByQuadrant,
   hasActiveUI: () => hasActiveUI,
+  isAnchorTargetingWorkspace: () => isAnchorTargetingWorkspace,
   isSameOrSubPath: () => isSameOrSubPath,
   makeSafeTaskAnnotation: () => makeSafeTaskAnnotation,
   matchAnchorAgainstTouchedFiles: () => matchAnchorAgainstTouchedFiles,
@@ -68,9 +70,11 @@ __export(index_exports, {
   renderActiveAnchorsContext: () => renderActiveAnchorsContext,
   renderColdStartAnchorsContext: () => renderColdStartAnchorsContext,
   runPhysicalVerification: () => runPhysicalVerification,
+  sortAnchorsForDisplay: () => sortAnchorsForDisplay,
   stripAnsi: () => stripAnsi,
   sweepStore: () => sweepStore,
   truncateToWidth: () => truncateToWidth,
+  tryRealtimeAutoSettle: () => tryRealtimeAutoSettle,
   updateAnchorStatusBar: () => updateAnchorStatusBar,
   updateStartupBanner: () => updateStartupBanner
 });
@@ -78,23 +82,23 @@ module.exports = __toCommonJS(index_exports);
 
 // 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
+  activeDays: 7,
+  // 7 days active before quiet sleep
+  sleepDays: 30,
+  graveyardDays: 9999
+  // Never silently auto-delete unfinished tasks
 };
 var DURABLE_DECAY_POLICY = {
-  activeDays: 3,
+  activeDays: 7,
+  // 7 days active before quiet sleep
   sleepDays: 30,
   graveyardDays: 9999
   // Never permanently auto-dropped; preserved indefinitely
 };
 var DEFAULT_DECAY_POLICY = {
-  activeDays: 3,
-  sleepDays: 7,
-  graveyardDays: 14
+  activeDays: 7,
+  sleepDays: 30,
+  graveyardDays: 9999
 };
 
 // src/store.ts
@@ -133,6 +137,39 @@ function isSameOrSubPath(anchorCwd, targetCwd) {
   const cmpT = isWinStyle ? normT.toLowerCase() : normT;
   return cmpA === cmpT || cmpT.startsWith(cmpA + "/") || cmpA.startsWith(cmpT + "/");
 }
+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;
+    const projBase = import_node_path.default.basename(normProj).toLowerCase();
+    if (projBase && projBase === 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;
   const normTouched = touchedFiles.map((f) => normalizePath(f, anchor.cwd)).filter(Boolean);
@@ -235,10 +272,10 @@ function detectDurability(title) {
 function getEphemeralDecayPolicy(title) {
   const lower = title.toLowerCase();
   if (lower.includes("\u5927\u540E\u5929")) {
-    return { activeDays: 3, sleepDays: 1, graveyardDays: 4 };
+    return { activeDays: 7, sleepDays: 30, graveyardDays: 9999 };
   }
   if (lower.includes("\u540E\u5929")) {
-    return { activeDays: 2, sleepDays: 1, graveyardDays: 3 };
+    return { activeDays: 7, sleepDays: 30, graveyardDays: 9999 };
   }
   return { ...EPHEMERAL_DECAY_POLICY };
 }
@@ -549,7 +586,17 @@ var AnchorStore = class {
       const state = this.loadState();
       const now = Date.now();
       const id = this.generateId(state);
-      const cwd = input.cwd ? normalizePath(input.cwd) : "";
+      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_path2.default.dirname(inferredFiles[0]);
+        if (firstDir && firstDir !== ".") {
+          cwd = normalizePath(firstDir);
+        }
+      }
       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);
@@ -569,7 +616,7 @@ var AnchorStore = class {
         createdAt: now,
         updatedAt: now,
         lastTouchedAt: now,
-        files: (input.files || []).map((f) => normalizePath(f)).filter(Boolean),
+        files: inferredFiles,
         tags: (input.tags || []).map((t) => t.trim()).filter(Boolean),
         verifyCommand: input.verifyCommand?.trim() || void 0,
         decay: input.decay ? { ...input.decay } : { ...decayPolicy }
@@ -608,7 +655,7 @@ var AnchorStore = class {
       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;
         }
       }
@@ -928,20 +975,66 @@ function runPhysicalVerification(anchor, cwd) {
     return { success: false, output: String(err.stderr || err.stdout || err.message).trim() };
   }
 }
-function generateSettlementProposals(store, touchedFiles, cwd) {
+function tryRealtimeAutoSettle(store, observer, cwd, executedCommand) {
+  const candidates = store.list({ cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
+  if (candidates.length === 0) return [];
+  const settledList = [];
+  const cmdTrimmed = (executedCommand || "").trim();
+  for (const a of candidates) {
+    if (observer.hasCommitted()) {
+      const commitMatch = observer.matchesCommit(a);
+      if (commitMatch.matched && (!cwd || isAnchorTargetingWorkspace(a, cwd))) {
+        const settled = store.settle(a.id, {
+          settledBy: "verification-test",
+          summary: `Auto-settled via Git commit: ${commitMatch.message}`,
+          touchedFiles: observer.getModifiedFiles()
+        });
+        settledList.push({ anchor: settled, reason: `git commit ("${commitMatch.message}")` });
+        continue;
+      }
+    }
+    if (a.verifyCommand && cmdTrimmed && cmdTrimmed.includes(a.verifyCommand.trim())) {
+      const settled = store.settle(a.id, {
+        settledBy: "verification-test",
+        summary: `Auto-settled via passing command: ${a.verifyCommand}`,
+        touchedFiles: observer.getModifiedFiles()
+      });
+      settledList.push({ anchor: settled, reason: `verifyCommand (${a.verifyCommand})` });
+    }
+  }
+  return settledList;
+}
+function generateSettlementProposals(store, touchedFiles, cwd, observer) {
   const activeAndSleeping = store.list({ cwd }).filter((a) => a.status === "active" || a.status === "sleeping");
   const matches = findMatchedAnchors(activeAndSleeping, touchedFiles);
+  const seenIds = /* @__PURE__ */ new Set();
   const proposals = [];
   for (const match of matches) {
+    seenIds.add(match.anchor.id);
     const fileList = match.matchedFiles.slice(0, 3).join(", ");
-    const moreSuffix = match.matchedFiles.length > 3 ? ` \u7B49 ${match.matchedFiles.length} \u4E2A\u6587\u4EF6` : "";
+    const moreSuffix = match.matchedFiles.length > 3 ? ` (+${match.matchedFiles.length - 3} more)` : "";
     proposals.push({
       anchor: match.anchor,
       matchedFiles: match.matchedFiles,
-      reason: `\u672C\u6B21\u4F1A\u8BDD\u4FEE\u6539\u4E86 ${fileList}${moreSuffix}`,
+      reason: `Modified ${fileList}${moreSuffix}`,
       recommendedAction: match.score >= 0.85 ? "settle" : "defer"
     });
   }
+  if (observer && observer.hasCommitted()) {
+    for (const a of activeAndSleeping) {
+      if (seenIds.has(a.id)) continue;
+      const cm = observer.matchesCommit(a);
+      if (cm.matched) {
+        seenIds.add(a.id);
+        proposals.push({
+          anchor: a,
+          matchedFiles: touchedFiles.slice(0, 3),
+          reason: `Matched git commit: "${cm.message}"`,
+          recommendedAction: "settle"
+        });
+      }
+    }
+  }
   return proposals;
 }
 function formatSettlementCard(proposal) {
@@ -989,6 +1082,27 @@ function groupAnchorsByQuadrant(anchors, now = Date.now()) {
   }
   return groups;
 }
+var PRIORITY_RANK = { p0: 0, p1: 1, p2: 2 };
+function sortAnchorsForDisplay(anchors, cwd, now = Date.now()) {
+  const todayStr = getTodayDateString(now);
+  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;
+    }
+    const aDue = a.targetDate && a.targetDate <= todayStr ? 0 : 1;
+    const bDue = b.targetDate && b.targetDate <= todayStr ? 0 : 1;
+    if (aDue !== bDue) return aDue - bDue;
+    const pA = PRIORITY_RANK[a.priority] ?? 1;
+    const pB = PRIORITY_RANK[b.priority] ?? 1;
+    if (pA !== pB) return pA - pB;
+    return a.createdAt - b.createdAt;
+  });
+}
 var ANSI_REGEX = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
 function stripAnsi(str) {
   return str.replace(ANSI_REGEX, "");
@@ -1117,11 +1231,19 @@ function formatRemainingTtl(anchor, now = Date.now()) {
 }
 function formatOrigin(anchor) {
   if (typeof anchor === "object") {
-    if (!anchor.cwd) return anchor.project || "global";
-    return import_node_path3.default.basename(anchor.cwd) || "global";
+    if (anchor.project && anchor.project !== "global") {
+      const normProj = anchor.project.replace(/\\/g, "/").replace(/\/+$/, "");
+      if (normProj.includes("/")) {
+        const parts = normProj.split("/").filter(Boolean);
+        return parts.slice(-2).join("/");
+      }
+      return normProj;
+    }
+    if (!anchor.cwd) return "global";
+    return import_node_path3.default.basename(anchor.cwd.replace(/\\/g, "/")) || "global";
   }
   if (!anchor) return "global";
-  return import_node_path3.default.basename(anchor) || "global";
+  return import_node_path3.default.basename(anchor.replace(/\\/g, "/")) || "global";
 }
 function updateAnchorStatusBar(ctx, store) {
   if (!hasActiveUI(ctx)) return;
@@ -1176,51 +1298,47 @@ 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) {
+  const allUnfinished = store.list({ cwd: ctx.cwd, all: true }).filter((a) => a.status === "active" || a.status === "sleeping");
+  if (allUnfinished.length === 0) {
     ctx.ui.notify("\u2316 No active anchors. Use /pin <task> to record.", "info");
     return;
   }
-  const groups = groupAnchorsByQuadrant(list);
-  const sortedList = [
-    ...groups.today,
-    ...groups.upcoming,
-    ...groups.habits,
-    ...groups.backlog
-  ];
+  const sortedList = sortAnchorsForDisplay(allUnfinished, 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;
+  const titleWidth = isNarrow ? Math.max(18, termCols - 36) : 36;
   for (let i = 0; i < sortedList.length; i++) {
     const a = sortedList[i];
     const num = a.id.replace(/^anc-/, "").padStart(2, "0");
-    const category = padToWidth(`[${classifyAnchor(a)}]`, 12);
+    const badge = a.status === "sleeping" ? padToWidth("[Quiet]", 10) : padToWidth(`[${a.priority.toUpperCase()}]`, 10);
     const origin = formatOrigin(a);
-    const target = formatTargetDate(a);
+    const target = a.status === "sleeping" ? "Quiet (0 tok)" : 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 colNum = `${num}  `;
     const colTitle = padToWidth(titleWithFiles, titleWidth);
-    const colOrigin = padToWidth(origin, 10);
-    const colTarget = padToWidth(target, 12);
+    const colOrigin = padToWidth(origin, 12);
+    const colTarget = padToWidth(target, 14);
     const colCreated = created;
-    const label = isNarrow ? `${colNum}${category}${colTitle}  ${colTarget}`.trimEnd() : `${colNum}${category}${colTitle}  ${colOrigin}  ${colTarget}  ${colCreated}`.trimEnd();
+    const label = isNarrow ? `${colNum}${badge}${colTitle}  ${colTarget}`.trimEnd() : `${colNum}${badge}${colTitle}  ${colOrigin}  ${colTarget}  ${colCreated}`.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 Anchors (select to settle, wake, or inspect):", displayOptions);
   if (!selected) return;
   const anchor = optionMap.get(selected);
   if (!anchor) return;
+  const actions = [
+    "\u2713 Settle (Mark completed and archive)",
+    ...anchor.status === "sleeping" ? ["\u26A1 Wake up (Activate for current session)"] : [],
+    "\u2139 View details & associated files",
+    "\u21A9 Cancel"
+  ];
   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"
-    ]
+    actions
   );
   if (!action || action.startsWith("\u21A9")) return;
   if (action.startsWith("\u2713")) {
@@ -1228,9 +1346,13 @@ async function openAnchorDashboard(ctx, store) {
     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");
     updateAnchorStatusBar(ctx, store);
+  } else if (action.startsWith("\u26A1")) {
+    store.touch(anchor.id);
+    ctx.ui.notify(`\u2316 Woke up #${anchor.id}: "${anchor.title}"`, "info");
+    updateAnchorStatusBar(ctx, store);
   } else if (action.startsWith("\u2139")) {
     const details = [
-      `#${anchor.id} [${anchor.priority.toUpperCase()}] ${anchor.title}`,
+      `#${anchor.id} [${anchor.priority.toUpperCase()} \xB7 ${anchor.status.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,
@@ -1549,6 +1671,7 @@ var AnchorProtocol = class {
   detectRecurrence,
   detectTargetDate,
   evaluateAnchorDecay,
+  extractPathsFromText,
   findMatchedAnchors,
   formatCreationTime,
   formatOrigin,
@@ -1564,6 +1687,7 @@ var AnchorProtocol = class {
   globToRegExp,
   groupAnchorsByQuadrant,
   hasActiveUI,
+  isAnchorTargetingWorkspace,
   isSameOrSubPath,
   makeSafeTaskAnnotation,
   matchAnchorAgainstTouchedFiles,
@@ -1573,9 +1697,11 @@ var AnchorProtocol = class {
   renderActiveAnchorsContext,
   renderColdStartAnchorsContext,
   runPhysicalVerification,
+  sortAnchorsForDisplay,
   stripAnsi,
   sweepStore,
   truncateToWidth,
+  tryRealtimeAutoSettle,
   updateAnchorStatusBar,
   updateStartupBanner
 });