pi-anchor 0.2.0 → 0.2.2

package/dist/extension.cjs

@@ -59,20 +59,34 @@ var DURABLE_DECAY_POLICY = {
 // src/matcher.ts
 var import_node_path = __toESM(require("path"), 1);
 function globToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*\//g, "___GLOB_DIR_SLASH___").replace(/\*\*/g, "___GLOB_STAR_STAR___").replace(/\*/g, "[^/]*").replace(/___GLOB_DIR_SLASH___/g, "(?:/|/.+/)").replace(/___GLOB_STAR_STAR___/g, ".*");
+  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 normalizePath(filePath, baseCwd) {
   if (typeof filePath !== "string") return "";
   let norm = filePath.trim().replace(/\\/g, "/").replace(/^\.\//, "");
-  if (baseCwd && (import_node_path.default.isAbsolute(filePath) || norm.startsWith("/"))) {
-    const normBase = baseCwd.trim().replace(/\\/g, "/");
-    if (norm.toLowerCase().startsWith(normBase.toLowerCase())) {
-      norm = norm.slice(normBase.length).replace(/^\/+/, "");
+  if (baseCwd && (import_node_path.default.isAbsolute(filePath) || norm.startsWith("/") || /^[a-zA-Z]:\//.test(norm))) {
+    const normBase = baseCwd.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    const lowerNorm = norm.toLowerCase();
+    const lowerBase = normBase.toLowerCase();
+    if (lowerNorm === lowerBase) {
+      norm = "";
+    } else if (lowerNorm.startsWith(lowerBase + "/")) {
+      norm = norm.slice(normBase.length + 1).replace(/^\/+/, "");
     }
   }
   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 matchAnchorAgainstTouchedFiles(anchor, touchedFiles) {
   if (!anchor.files || anchor.files.length === 0) return null;
   const normTouched = touchedFiles.map((f) => normalizePath(f, anchor.cwd)).filter(Boolean);
@@ -434,9 +448,19 @@ var AnchorStore = class {
     }
     try {
       const data = JSON.parse(raw);
-      if (!Array.isArray(data.anchors)) {
+      if (!data || typeof data !== "object" || !Array.isArray(data.anchors)) {
         throw new Error("Invalid state: anchors must be array");
       }
+      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;
     } catch {
       const backupPath = import_node_path2.default.join(this.storageDir, `state.corrupt.${Date.now()}.json`);
@@ -456,16 +480,19 @@ var AnchorStore = class {
    */
   saveState(state) {
     this.ensureDirs();
-    const tempPath = import_node_path2.default.join(this.storageDir, `state.tmp.${process.pid}.${Date.now()}`);
+    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}`);
     import_node_fs.default.writeFileSync(tempPath, JSON.stringify(state, null, 2), "utf-8");
     atomicRenameWithRetry(tempPath, this.statePath);
   }
-  generateId(existingAnchors) {
-    const numbers = existingAnchors.map((a) => {
+  generateId(state) {
+    const numbers = state.anchors.map((a) => {
       const match = a.id.match(/^anc-(\d+)$/);
       return match ? parseInt(match[1], 10) : 0;
     }).filter((n) => n > 0);
-    const nextNum = numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
+    const maxExisting = numbers.length > 0 ? Math.max(...numbers) : 0;
+    const nextNum = Math.max(maxExisting + 1, state.nextId || 1);
+    state.nextId = nextNum + 1;
     return `anc-${nextNum}`;
   }
   /**
@@ -475,7 +502,7 @@ var AnchorStore = class {
     return this.withLock(() => {
       const state = this.loadState();
       const now = Date.now();
-      const id = this.generateId(state.anchors);
+      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);
@@ -535,7 +562,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 && a.cwd !== targetCwd) {
+        if (a.files.length > 0 && a.cwd && !isSameOrSubPath(a.cwd, targetCwd)) {
           return false;
         }
       }
@@ -636,18 +663,46 @@ var AnchorStore = class {
         throw new Error("No archived anchors to undo");
       }
       const raw = import_node_fs.default.readFileSync(this.archivePath, "utf-8");
-      const lines = raw.split("\n").filter(Boolean);
-      if (lines.length === 0) {
+      const lines = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      let anchor = null;
+      while (lines.length > 0 && !anchor) {
+        const candidate = lines.pop();
+        try {
+          const parsed = JSON.parse(candidate);
+          if (parsed && typeof parsed === "object" && typeof parsed.id === "string" && typeof parsed.title === "string") {
+            anchor = parsed;
+          }
+        } catch {
+        }
+      }
+      if (!anchor) {
         throw new Error("Archive is empty, nothing to undo");
       }
-      const lastLine = lines.pop();
-      const anchor = JSON.parse(lastLine);
       import_node_fs.default.writeFileSync(this.archivePath, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
       anchor.status = "active";
       anchor.updatedAt = Date.now();
       delete anchor.evidence;
+      delete anchor.settledForDate;
+      if (anchor.recurrence === "daily") {
+        delete anchor.lastCompletedDate;
+      }
       const state = this.loadState();
-      state.anchors.push(anchor);
+      const existingIdx = state.anchors.findIndex((a) => a.id === anchor.id);
+      if (existingIdx !== -1) {
+        if (state.anchors[existingIdx].title === anchor.title) {
+          state.anchors[existingIdx] = anchor;
+        } else {
+          anchor.id = this.generateId(state);
+          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);
+        }
+        state.anchors.push(anchor);
+      }
       this.saveState(state);
       return anchor;
     });
@@ -679,10 +734,19 @@ var AnchorStore = class {
     if (!import_node_fs.default.existsSync(this.archivePath)) return [];
     try {
       const raw = import_node_fs.default.readFileSync(this.archivePath, "utf-8");
-      const all = raw.split("\n").filter(Boolean).map((l) => JSON.parse(l));
+      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 || a.cwd === targetCwd);
+      return all.filter((a) => !a.cwd || isSameOrSubPath(a.cwd, targetCwd));
     } catch {
       return [];
     }
@@ -691,10 +755,19 @@ var AnchorStore = class {
     if (!import_node_fs.default.existsSync(this.graveyardPath)) return [];
     try {
       const raw = import_node_fs.default.readFileSync(this.graveyardPath, "utf-8");
-      const all = raw.split("\n").filter(Boolean).map((l) => JSON.parse(l));
+      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 || a.cwd === targetCwd);
+      return all.filter((a) => !a.cwd || isSameOrSubPath(a.cwd, targetCwd));
     } catch {
       return [];
     }
@@ -850,56 +923,58 @@ function evaluateAnchorDecay(anchor, now = Date.now()) {
   };
 }
 function sweepStore(store, now = Date.now()) {
-  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;
+  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);
+    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;
+    state.lastSweepAt = now;
+    if (stateModified) {
+      store.saveState(state);
+    }
+    return result;
+  });
 }
 
 // src/context_injector.ts
@@ -1023,14 +1098,16 @@ function renderColdStartAnchorsContext(store, cwdOrNow, nowArg, preflightFailure
 // src/settlement.ts
 var import_node_child_process = require("child_process");
 function runPhysicalVerification(anchor, cwd) {
-  if (!anchor.verifyCommand) {
+  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,
+      cwd: targetCwd,
       encoding: "utf-8",
-      timeout: 3e4,
+      timeout: 8e3,
+      maxBuffer: 4 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
     });
     return { success: true, output: stdout.trim() };
@@ -1086,8 +1163,9 @@ function groupAnchorsByQuadrant(anchors, now = Date.now()) {
   }
   return groups;
 }
+var ANSI_REGEX = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
 function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+  return str.replace(ANSI_REGEX, "");
 }
 function getDisplayWidth(str) {
   const clean = stripAnsi(str);
@@ -1105,23 +1183,46 @@ function getDisplayWidth(str) {
   }
   return width;
 }
+function hasActiveUI(ctx) {
+  if (!ctx) return false;
+  try {
+    return Boolean(ctx.hasUI && ctx.ui);
+  } catch {
+    return false;
+  }
+}
 function truncateToWidth(str, maxWidth, ellipsis = "\u2026") {
-  const current = getDisplayWidth(str);
-  if (current <= maxWidth) return str;
+  if (maxWidth <= 0) return "";
+  const singleLine = str.replace(/[\r\n\t]+/g, " ");
+  const totalWidth = getDisplayWidth(singleLine);
+  if (totalWidth <= maxWidth) return singleLine;
   const ellipsisWidth = getDisplayWidth(ellipsis);
-  const target = maxWidth - ellipsisWidth;
-  if (target <= 0) return ellipsis.slice(0, maxWidth);
+  const target = Math.max(0, maxWidth - ellipsisWidth);
+  if (target === 0) return ellipsis.slice(0, maxWidth);
   let accumulated = "";
   let accumWidth = 0;
-  for (const char of str) {
-    const charWidth = getDisplayWidth(char);
+  let i = 0;
+  while (i < singleLine.length) {
+    ANSI_REGEX.lastIndex = i;
+    const match = ANSI_REGEX.exec(singleLine);
+    if (match && match.index === i) {
+      accumulated += match[0];
+      i += match[0].length;
+      continue;
+    }
+    const codePoint = singleLine.codePointAt(i) || 0;
+    const charLen = codePoint > 65535 ? 2 : 1;
+    const fullChar = singleLine.slice(i, i + charLen);
+    const charWidth = getDisplayWidth(fullChar);
     if (accumWidth + charWidth > target) {
       break;
     }
-    accumulated += char;
+    accumulated += fullChar;
     accumWidth += charWidth;
+    i += charLen;
   }
-  return accumulated + ellipsis;
+  accumulated = accumulated.replace(/\s*[\(\[\{（【]$/, "");
+  return accumulated + ellipsis + (singleLine.includes("\x1B") ? "\x1B[0m" : "");
 }
 function padToWidth(str, targetWidth) {
   const truncated = truncateToWidth(str, targetWidth);
@@ -1191,52 +1292,58 @@ function formatOrigin(anchor) {
   return import_node_path4.default.basename(anchor) || "global";
 }
 function updateAnchorStatusBar(ctx, store) {
-  if (!ctx.hasUI || !ctx.ui) return;
-  const active = store.list({ status: "active", cwd: ctx.cwd });
-  if (active.length === 0) {
-    ctx.ui.setStatus("anchor", void 0);
-    return;
+  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}`);
+  } catch {
   }
-  ctx.ui.setStatus("anchor", `\u2316 ${active.length}`);
 }
 function updateStartupBanner(ctx, store) {
-  if (!ctx.hasUI || !ctx.ui) return;
-  const active = store.list({ status: "active", cwd: ctx.cwd });
-  if (active.length === 0) {
-    ctx.ui.setWidget("anchor-startup", void 0);
-    return;
-  }
-  const groups = groupAnchorsByQuadrant(active);
-  const sorted = [...groups.today, ...groups.upcoming, ...groups.habits, ...groups.backlog];
-  const topItems = sorted.slice(0, 3);
-  const factory = (_tui, theme) => ({
-    render: (width) => {
-      const maxTitleWidth = Math.max(16, width - 36);
-      const fg = theme?.fg ? theme.fg.bind(theme) : (_c, text) => text;
-      const lines = [
-        fg("accent", `\u2316 Anchor \xB7 ${active.length} active commitments:`)
-      ];
-      for (let i = 0; i < topItems.length; i++) {
-        const a = topItems[i];
-        const num = (i + 1).toString().padStart(2, "0");
-        const q = classifyAnchor(a);
-        const tgt = formatTargetDate(a);
-        const titlePadded = truncateToWidth(a.title, maxTitleWidth);
-        lines.push(`  \u2022 ${fg("muted", `[${q}]`)}  ${fg("dim", num)} ${titlePadded} ${fg("dim", `(${tgt})`)}`);
-      }
-      if (sorted.length > 3) {
-        lines.push(fg("dim", `  (+${sorted.length - 3} more \xB7 run /anchor to inspect)`));
-      }
-      return lines;
-    },
-    invalidate: () => {
+  if (!hasActiveUI(ctx)) return;
+  try {
+    const active = store.list({ status: "active", cwd: ctx.cwd });
+    if (active.length === 0) {
+      ctx.ui.setWidget("anchor-startup", void 0);
+      return;
     }
-  });
-  const content = ctx.ui?.theme ? factory : factory().render(80);
-  ctx.ui.setWidget("anchor-startup", content, { placement: "aboveEditor" });
+    const groups = groupAnchorsByQuadrant(active);
+    const sorted = [...groups.today, ...groups.upcoming, ...groups.habits, ...groups.backlog];
+    const topItems = sorted.slice(0, 3);
+    const factory = (_tui, theme) => ({
+      render: (width) => {
+        const maxTitleWidth = Math.max(12, width - 36);
+        const fg = theme?.fg ? theme.fg.bind(theme) : (_c, text) => text;
+        const lines = [
+          truncateToWidth(fg("accent", `\u2316 Anchor \xB7 ${active.length} active commitments:`), width)
+        ];
+        for (let i = 0; i < topItems.length; i++) {
+          const a = topItems[i];
+          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));
+        }
+        if (sorted.length > 3) {
+          lines.push(truncateToWidth(fg("dim", `  (+${sorted.length - 3} more \xB7 run /anchor to inspect)`), width));
+        }
+        return lines;
+      },
+      invalidate: () => {
+      }
+    });
+    const content = ctx.ui?.theme ? factory : factory().render(80);
+    ctx.ui.setWidget("anchor-startup", content, { placement: "aboveEditor" });
+  } catch {
+  }
 }
 async function openAnchorDashboard(ctx, store) {
-  if (!ctx.hasUI || !ctx.ui) return;
+  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");
@@ -1251,31 +1358,55 @@ async function openAnchorDashboard(ctx, store) {
   ];
   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 num = (i + 1).toString().padStart(2, "0");
+    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 colNum = `${num}  `;
-    const colTitle = padToWidth(titleWithFiles, 34);
+    const colTitle = padToWidth(titleWithFiles, titleWidth);
     const colOrigin = padToWidth(origin, 10);
     const colTarget = padToWidth(target, 12);
     const colCreated = created;
-    const label = `${colNum}${category}${colTitle}  ${colOrigin}  ${colTarget}  ${colCreated}`.trimEnd();
+    const label = isNarrow ? `${colNum}${category}${colTitle}  ${colTarget}`.trimEnd() : `${colNum}${category}${colTitle}  ${colOrigin}  ${colTarget}  ${colCreated}`.trimEnd();
     optionMap.set(label, a);
     displayOptions.push(label);
   }
-  const selected = await ctx.ui.select("\u2316 Anchors (enter to complete):", displayOptions);
+  const selected = await ctx.ui.select("\u2316 Anchors (select to inspect or settle):", displayOptions);
   if (!selected) return;
   const anchor = optionMap.get(selected);
   if (!anchor) return;
-  store.settle(anchor.id, { settledBy: "manual-command" });
-  const successMsg = anchor.recurrence === "daily" ? `\u2316 Completed for today: "${anchor.title}" (resets tomorrow)` : `\u2316 Settled: "${anchor.title}"`;
-  ctx.ui.notify(successMsg, "info");
-  updateAnchorStatusBar(ctx, store);
+  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"
+    ]
+  );
+  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");
+    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"})`
+    ].filter(Boolean).join("\n");
+    ctx.ui.notify(details, "info");
+  }
 }
 
 // src/extension.ts
@@ -1298,7 +1429,7 @@ function extension_default(pi) {
     }
     const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
     for (const a of activeAnchors) {
-      if (a.verifyCommand) {
+      if (a.verifyCommand && (!a.cwd || isSameOrSubPath(a.cwd, ctx.cwd))) {
         try {
           const res = runPhysicalVerification(a, ctx.cwd);
           if (res.success) {
@@ -1319,21 +1450,32 @@ function extension_default(pi) {
       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"));
-        if (pending.cwd === ctx.cwd && Date.now() - pending.timestamp < 24 * 60 * 60 * 1e3) {
-          ctx.ui.notify(`\u2316 [Anchor \u9000\u51FA\u5B88\u62A4] \u68C0\u6D4B\u5230\u4E0A\u6B21\u5F02\u5E38\u9000\u51FA\u4E14\u6709 ${pending.modifiedCount} \u4E2A\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u53EF\u7528 anchor(action="pin") \u56FA\u5316\u4EFB\u52A1\u3002`, "info");
+        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);
         }
-        import_node_fs3.default.unlinkSync(pendingPath);
       }
     } catch (_) {
     }
     updateAnchorStatusBar(ctx, store);
     if (event.reason !== "resume") {
       updateStartupBanner(ctx, store);
+    } else if (hasActiveUI(ctx)) {
+      try {
+        ctx.ui.setWidget("anchor-startup", void 0);
+      } catch {
+      }
     }
   });
   pi.on("agent_start", async (_event, ctx) => {
-    if (ctx.hasUI && ctx.ui) {
-      ctx.ui.setWidget("anchor-startup", void 0);
+    if (hasActiveUI(ctx)) {
+      try {
+        ctx.ui.setWidget("anchor-startup", void 0);
+      } catch {
+      }
     }
   });
   pi.on("before_agent_start", async (event, ctx) => {
@@ -1357,7 +1499,7 @@ ${contextSnippet}`
     }
     const pathInput = event.input?.path;
     if (typeof pathInput !== "string") return;
-    const touchedPath = normalizePath(pathInput);
+    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) {
@@ -1385,20 +1527,37 @@ ${contextSnippet}`
       }
     }
   });
-  pi.on("session_shutdown", async (_event, ctx) => {
+  pi.on("session_shutdown", async (event, ctx) => {
+    let gitStatus = "";
     try {
-      const gitStatus = (0, import_node_child_process2.execSync)("git status --porcelain", {
+      gitStatus = (0, import_node_child_process2.execSync)("git status --porcelain", {
         cwd: ctx.cwd,
         encoding: "utf-8",
-        timeout: 3e3,
+        timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
-      });
-      const changed = gitStatus.split("\n").map((l) => l.slice(3).trim()).filter(Boolean);
+      }).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 modified = observer.getModifiedFiles();
     if (modified.length === 0) return;
     const proposals = generateSettlementProposals(store, modified, ctx.cwd);
@@ -1412,7 +1571,12 @@ ${contextSnippet}`
           summary: `Auto-settled via Git commit: ${commitMatch.message}`,
           touchedFiles: prop.matchedFiles
         });
-        ctx.ui.notify(`\u2316 Auto-settled #${a.id} via Git commit (run /anchor undo to revert)`, "info");
+        if (hasActiveUI(ctx)) {
+          try {
+            ctx.ui.notify(`\u2316 Auto-settled #${a.id} via Git commit (run /anchor undo to revert)`, "info");
+          } catch {
+          }
+        }
         continue;
       }
       if (a.verifyCommand) {
@@ -1423,22 +1587,30 @@ ${contextSnippet}`
             summary: `Automated test passed: ${a.verifyCommand}`,
             touchedFiles: prop.matchedFiles
           });
-          ctx.ui.notify(`\u2316 Test passed (${a.verifyCommand}), auto-settled #${a.id}`, "info");
+          if (hasActiveUI(ctx)) {
+            try {
+              ctx.ui.notify(`\u2316 Test passed (${a.verifyCommand}), auto-settled #${a.id}`, "info");
+            } catch {
+            }
+          }
           continue;
         }
       }
-      if (!ctx.hasUI || !ctx.ui) continue;
-      const ok = await ctx.ui.confirm(
-        "\u2316 Settle Anchor Task",
-        `Task #${a.id} [${a.title}] touched files (${prop.matchedFiles.slice(0, 2).join(", ")}).
+      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");
+        );
+        if (ok) {
+          store.settle(a.id, {
+            settledBy: "one-tap-settlement",
+            touchedFiles: prop.matchedFiles
+          });
+          ctx.ui.notify(`\u2316 Settled #${a.id}: "${a.title}"`, "info");
+        }
+      } catch {
       }
     }
   });
@@ -1488,7 +1660,7 @@ Mark as completed and archive?`
         if (args.priority) title += ` ${theme.fg("muted", `[${args.priority}]`)}`;
       }
       return {
-        render: () => [title],
+        render: (width) => [truncateToWidth(title, width)],
         invalidate: () => {
         }
       };
@@ -1497,14 +1669,14 @@ Mark as completed and archive?`
       if (result.isError) {
         const errText = result.content?.[0]?.text || "Execution failed";
         return {
-          render: () => [theme.fg("error", `\u2717 ${errText}`)],
+          render: (width) => [truncateToWidth(theme.fg("error", `\u2717 ${errText}`), width)],
           invalidate: () => {
           }
         };
       }
       const text = result.content?.[0]?.text || "OK";
       return {
-        render: () => [theme.fg("success", `\u2714 ${text}`)],
+        render: (width) => [truncateToWidth(theme.fg("success", `\u2714 ${text}`), width)],
         invalidate: () => {
         }
       };
@@ -1640,28 +1812,10 @@ Mark as completed and archive?`
       updateAnchorStatusBar(ctx, store);
     }
   });
-  pi.on("session_shutdown", async (event, ctx) => {
-    if (event.reason === "quit") {
-      try {
-        const gitStatus = (0, import_node_child_process2.execSync)("git status --porcelain", {
-          cwd: ctx.cwd,
-          encoding: "utf-8",
-          timeout: 2e3,
-          stdio: ["ignore", "pipe", "ignore"]
-        }).trim();
-        const activeAnchors = store.list({ cwd: ctx.cwd }).filter((a) => a.status === "active");
-        if (gitStatus && 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 (_) {
-      }
+  pi.registerCommand("anchors", {
+    description: "Inspect and settle active anchors",
+    handler: async (_args, ctx) => {
+      await openAnchorDashboard(ctx, store);
     }
   });
 }