pi-anchor 0.2.1 → 0.2.3

package/src/decay.ts

@@ -61,63 +61,65 @@ export interface SweepResult {
  * Run decay sweep across store: transitions statuses and evicts expired anchors
  */
 export function sweepStore(store: AnchorStore, now: number = Date.now()): SweepResult {
-  const state = store.loadState();
-  const result: SweepResult = {
-    transitionedToSleeping: [],
-    wokenToActive: [],
-    evictedToGraveyard: []
-  };
+  return store.withLock(() => {
+    const state = store.loadState();
+    const result: SweepResult = {
+      transitionedToSleeping: [],
+      wokenToActive: [],
+      evictedToGraveyard: []
+    };
 
-  const toEvict: Anchor[] = [];
-  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;
+    const toEvict: Anchor[] = [];
+    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;
+        }
       }
     }
-  }
 
-  // Single-pass batch eviction and state save
-  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';
-
-    fs.appendFileSync(store.graveyardPath, graveyardLines, 'utf-8');
-    for (const exp of toEvict) {
-      result.evictedToGraveyard.push(exp.id);
+    // Single-pass batch eviction and state save
+    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';
+
+      fs.appendFileSync(store.graveyardPath, graveyardLines, 'utf-8');
+      for (const exp of toEvict) {
+        result.evictedToGraveyard.push(exp.id);
+      }
     }
-  }
 
-  state.lastSweepAt = now;
-  if (stateModified) {
-    store.saveState(state);
-  }
+    state.lastSweepAt = now;
+    if (stateModified) {
+      store.saveState(state);
+    }
 
-  return result;
+    return result;
+  });
 }

package/src/extension.ts

@@ -4,9 +4,9 @@ import { AnchorStore } from './store.ts';
 import { SessionTouchObserver } from './observer.ts';
 import { renderColdStartAnchorsContext, renderActiveAnchorsContext, makeSafeTaskAnnotation } from './context_injector.ts';
 import { generateSettlementProposals, runPhysicalVerification } from './settlement.ts';
-import { normalizePath, findMatchedAnchors } from './matcher.ts';
+import { normalizePath, isSameOrSubPath, findMatchedAnchors } from './matcher.ts';
 import { sweepStore } from './decay.ts';
-import { updateAnchorStatusBar, openAnchorDashboard, updateStartupBanner, truncateToWidth } from './tui.ts';
+import { updateAnchorStatusBar, openAnchorDashboard, updateStartupBanner, truncateToWidth, hasActiveUI } from './tui.ts';
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -32,10 +32,10 @@ export default function (pi: ExtensionAPI) {
       ctx.ui.notify(`Anchor: ${sweep.transitionedToSleeping.length} 个非活跃任务已进入休眠`, 'info');
     }
 
-    // Physical Pre-flight Verification: auto-settle passing tasks or record failing output
+    // Physical Pre-flight Verification: auto-settle passing tasks or record failing output (scoped strictly to current cwd)
     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) {
@@ -57,10 +57,13 @@ export default function (pi: ExtensionAPI) {
       const pendingPath = path.join(home, '.anchor', 'pending_exit.json');
       if (fs.existsSync(pendingPath)) {
         const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
-        if (pending.cwd === ctx.cwd && Date.now() - pending.timestamp < 24 * 60 * 60 * 1000) {
-          ctx.ui.notify(`⌖ [Anchor 退出守护] 检测到上次异常退出且有 ${pending.modifiedCount} 个未提交改动，可用 anchor(action="pin") 固化任务。`, 'info');
+        const isExpired = Date.now() - pending.timestamp >= 24 * 60 * 60 * 1000;
+        if (!isExpired && isSameOrSubPath(pending.cwd, ctx.cwd)) {
+          ctx.ui.notify(`⌖ [Exit Guard] Detected ${pending.modifiedCount} uncommitted changes from previous session exit. Run /pin to record.`, 'info');
+          fs.unlinkSync(pendingPath);
+        } else if (isExpired) {
+          fs.unlinkSync(pendingPath);
         }
-        fs.unlinkSync(pendingPath);
       }
     } catch (_) {}
 
@@ -69,13 +72,19 @@ export default function (pi: ExtensionAPI) {
     // Only render startup banner on initial startup or new session, not on mid-session resume
     if (event.reason !== 'resume') {
       updateStartupBanner(ctx, store);
+    } else if (hasActiveUI(ctx)) {
+      try {
+        ctx.ui.setWidget('anchor-startup', undefined);
+      } catch {}
     }
   });
 
   // 2. Auto-clear startup banner when agent starts first turn to keep screen clean
   pi.on('agent_start', async (_event: any, ctx: ExtensionContext) => {
-    if (ctx.hasUI && ctx.ui) {
-      ctx.ui.setWidget('anchor-startup', undefined);
+    if (hasActiveUI(ctx)) {
+      try {
+        ctx.ui.setWidget('anchor-startup', undefined);
+      } catch {}
     }
   });
 
@@ -105,7 +114,7 @@ export default function (pi: ExtensionAPI) {
     const pathInput = (event.input as any)?.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]);
 
@@ -142,25 +151,43 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // 4. Session shutdown: One-tap settlement check scoped to current workspace
-  pi.on('session_shutdown', async (_event: any, ctx: ExtensionContext) => {
-    // Opportunistically scan git modified files
+  // 4. Session shutdown: Single-pass git inspection, one-tap settlement check & Exit Guard
+  pi.on('session_shutdown', async (event: any, ctx: ExtensionContext) => {
+    let gitStatus = '';
     try {
-      const gitStatus = execSync('git status --porcelain', {
+      gitStatus = execSync('git status --porcelain', {
         cwd: ctx.cwd,
         encoding: 'utf-8',
-        timeout: 3000,
+        timeout: 2000,
         stdio: ['ignore', 'pipe', 'ignore']
-      });
+      }).replace(/[\r\n]+$/, '');
       const changed = gitStatus
-        .split('\n')
-        .map((l: string) => l.slice(3).trim())
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((l: string) => l.slice(3).replace(/^"(.*)"$/, '$1').trim())
         .filter(Boolean);
       for (const f of changed) {
         observer.addTouchedFile(f);
       }
     } catch {}
 
+    // Exit Guard: detect uncommitted changes on abrupt session shutdown
+    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 = path.join(home, '.anchor', 'pending_exit.json');
+          const data = {
+            cwd: ctx.cwd,
+            timestamp: Date.now(),
+            modifiedCount: gitStatus.split('\n').filter(Boolean).length
+          };
+          fs.writeFileSync(pendingPath, JSON.stringify(data, null, 2), 'utf-8');
+        }
+      } catch {}
+    }
+
     const modified = observer.getModifiedFiles();
     if (modified.length === 0) return;
 
@@ -179,7 +206,11 @@ export default function (pi: ExtensionAPI) {
           summary: `Auto-settled via Git commit: ${commitMatch.message}`,
           touchedFiles: prop.matchedFiles
         });
-        ctx.ui.notify(`⌖ Auto-settled #${a.id} via Git commit (run /anchor undo to revert)`, 'info');
+        if (hasActiveUI(ctx)) {
+          try {
+            ctx.ui.notify(`⌖ Auto-settled #${a.id} via Git commit (run /anchor undo to revert)`, 'info');
+          } catch {}
+        }
         continue;
       }
 
@@ -192,26 +223,32 @@ export default function (pi: ExtensionAPI) {
             summary: `Automated test passed: ${a.verifyCommand}`,
             touchedFiles: prop.matchedFiles
           });
-          ctx.ui.notify(`⌖ Test passed (${a.verifyCommand}), auto-settled #${a.id}`, 'info');
+          if (hasActiveUI(ctx)) {
+            try {
+              ctx.ui.notify(`⌖ Test passed (${a.verifyCommand}), auto-settled #${a.id}`, 'info');
+            } catch {}
+          }
           continue;
         }
       }
 
       // 3. Fallback: Prompt user for one-tap settlement on exit
-      if (!ctx.hasUI || !ctx.ui) continue;
+      if (!hasActiveUI(ctx)) continue;
 
-      const ok = await ctx.ui.confirm(
-        '⌖ Settle Anchor Task',
-        `Task #${a.id} [${a.title}] touched files (${prop.matchedFiles.slice(0, 2).join(', ')}).\nMark as completed and archive?`
-      );
+      try {
+        const ok = await ctx.ui.confirm(
+          '⌖ Settle Anchor Task',
+          `Task #${a.id} [${a.title}] touched files (${prop.matchedFiles.slice(0, 2).join(', ')}).\nMark as completed and archive?`
+        );
 
-      if (ok) {
-        store.settle(a.id, {
-          settledBy: 'one-tap-settlement',
-          touchedFiles: prop.matchedFiles
-        });
-        ctx.ui.notify(`⌖ Settled #${a.id}: "${a.title}"`, 'info');
-      }
+        if (ok) {
+          store.settle(a.id, {
+            settledBy: 'one-tap-settlement',
+            touchedFiles: prop.matchedFiles
+          });
+          ctx.ui.notify(`⌖ Settled #${a.id}: "${a.title}"`, 'info');
+        }
+      } catch {}
     }
   });
 
@@ -435,29 +472,11 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // 7. Exit Guard: detect uncommitted changes on abrupt session shutdown
-  pi.on('session_shutdown', async (event: any, ctx: ExtensionContext) => {
-    if (event.reason === 'quit') {
-      try {
-        const gitStatus = execSync('git status --porcelain', {
-          cwd: ctx.cwd,
-          encoding: 'utf-8',
-          timeout: 2000,
-          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 = path.join(home, '.anchor', 'pending_exit.json');
-          const data = {
-            cwd: ctx.cwd,
-            timestamp: Date.now(),
-            modifiedCount: gitStatus.split('\n').filter(Boolean).length
-          };
-          fs.writeFileSync(pendingPath, JSON.stringify(data, null, 2), 'utf-8');
-        }
-      } catch (_) {}
+  // Alias /anchors to open dashboard
+  pi.registerCommand('anchors', {
+    description: 'Inspect and settle active anchors',
+    handler: async (_args: string, ctx: ExtensionContext) => {
+      await openAnchorDashboard(ctx, store);
     }
   });
 }

package/src/matcher.ts

@@ -5,12 +5,16 @@ import type { Anchor, TouchMatchResult } from './types.ts';
  * Convert simple glob pattern (e.g. *.ts, src/**\/*.ts, src/auth/*.ts) to RegExp
  */
 export function globToRegExp(pattern: string): RegExp {
-  const escaped = 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_DIR_SLASH___/g, '(?:/|/(?:[^/]+/)+)')
     .replace(/___GLOB_STAR_STAR___/g, '.*');
   return new RegExp(`^${escaped}$`);
 }
@@ -21,15 +25,32 @@ export function globToRegExp(pattern: string): RegExp {
 export function normalizePath(filePath: string, baseCwd?: string): string {
   if (typeof filePath !== 'string') return '';
   let norm = filePath.trim().replace(/\\/g, '/').replace(/^\.\//, '');
-  if (baseCwd && (path.isAbsolute(filePath) || norm.startsWith('/'))) {
-    const normBase = baseCwd.trim().replace(/\\/g, '/');
-    if (norm.toLowerCase().startsWith(normBase.toLowerCase())) {
-      norm = norm.slice(normBase.length).replace(/^\/+/, '');
+  if (baseCwd && (path.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;
 }
 
+/**
+ * Compare two workspace CWDs safely (case-insensitive on Windows, supports subdirectory scoping)
+ */
+export function isSameOrSubPath(anchorCwd?: string, targetCwd?: string): boolean {
+  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 + '/');
+}
+
 /**
  * Match touched files against an anchor's registered physical patterns
  * Only anchors with explicit files/globs/prefixes are matched against file touches.

package/src/settlement.ts

@@ -7,15 +7,17 @@ import { execSync } from 'node:child_process';
  * Execute physical verification test command for an anchor
  */
 export function runPhysicalVerification(anchor: Anchor, cwd: string): { success: boolean; output: string } {
-  if (!anchor.verifyCommand) {
+  if (!anchor.verifyCommand?.trim()) {
     return { success: false, output: 'No verification command specified' };
   }
 
+  const targetCwd = anchor.cwd || cwd;
   try {
     const stdout = execSync(anchor.verifyCommand, {
-      cwd,
+      cwd: targetCwd,
       encoding: 'utf-8',
-      timeout: 30000,
+      timeout: 8000,
+      maxBuffer: 4 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe']
     });
     return { success: true, output: stdout.trim() };

package/src/store.ts

@@ -11,7 +11,7 @@ import type {
   AnchorStoreState
 } from './types.ts';
 import { DEFAULT_DECAY_POLICY, DURABLE_DECAY_POLICY, EPHEMERAL_DECAY_POLICY } from './types.ts';
-import { normalizePath } from './matcher.ts';
+import { normalizePath, isSameOrSubPath } from './matcher.ts';
 
 /**
  * Detect whether a task is a short-term ephemeral reminder or a long-term architectural vision
@@ -340,9 +340,21 @@ export class AnchorStore {
 
     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: any) => a && typeof a === 'object' && typeof a.id === 'string' && typeof a.title === 'string')
+        .map((a: any) => ({
+          ...a,
+          files: Array.isArray(a.files) ? a.files.filter((f: unknown) => typeof f === 'string') : [],
+          tags: Array.isArray(a.tags) ? a.tags.filter((t: unknown) => 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 as AnchorStoreState;
     } catch {
       const backupPath = path.join(this.storageDir, `state.corrupt.${Date.now()}.json`);
@@ -362,19 +374,22 @@ export class AnchorStore {
    */
   public saveState(state: AnchorStoreState): void {
     this.ensureDirs();
-    const tempPath = path.join(this.storageDir, `state.tmp.${process.pid}.${Date.now()}`);
+    const rand = Math.random().toString(36).slice(2, 7);
+    const tempPath = path.join(this.storageDir, `state.tmp.${process.pid}.${Date.now()}.${rand}`);
     fs.writeFileSync(tempPath, JSON.stringify(state, null, 2), 'utf-8');
     atomicRenameWithRetry(tempPath, this.statePath);
   }
 
-  private generateId(existingAnchors: Anchor[]): string {
-    const numbers = existingAnchors
+  private generateId(state: AnchorStoreState): string {
+    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}`;
   }
 
@@ -398,7 +413,7 @@ export class AnchorStore {
     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
@@ -485,7 +500,7 @@ export class AnchorStore {
       // If an anchor has specific code files attached, scope it to that cwd.
       // If an anchor has NO code files attached (habits, general tasks, study), it is universal and visible everywhere!
       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;
         }
       }
@@ -604,14 +619,21 @@ export class AnchorStore {
       }
 
       const raw = fs.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: Anchor | null = 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: Anchor = JSON.parse(lastLine);
-
       // 1. Re-write archive without the last line
       fs.writeFileSync(this.archivePath, lines.length > 0 ? lines.join('\n') + '\n' : '', 'utf-8');
 
@@ -619,9 +641,28 @@ export class AnchorStore {
       anchor.status = 'active';
       anchor.updatedAt = Date.now();
       delete anchor.evidence;
+      delete (anchor as any).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;
@@ -658,10 +699,18 @@ export class AnchorStore {
     if (!fs.existsSync(this.archivePath)) return [];
     try {
       const raw = fs.readFileSync(this.archivePath, 'utf-8');
-      const all: Anchor[] = raw.split('\n').filter(Boolean).map((l: string) => JSON.parse(l));
+      const all: Anchor[] = [];
+      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 [];
     }
@@ -671,10 +720,18 @@ export class AnchorStore {
     if (!fs.existsSync(this.graveyardPath)) return [];
     try {
       const raw = fs.readFileSync(this.graveyardPath, 'utf-8');
-      const all: Anchor[] = raw.split('\n').filter(Boolean).map((l: string) => JSON.parse(l));
+      const all: Anchor[] = [];
+      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 [];
     }