pi-anchor 0.2.3 → 0.3.0

package/dist/store-t2_TDhJn.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Anchor Data Contracts & Type Definitions
+ * Single Global Source of Truth with Zero Workspace Contamination.
+ */
+type AnchorStatus = 'active' | 'sleeping' | 'settled' | 'graveyard';
+type AnchorPriority = 'p0' | 'p1' | 'p2';
+type AnchorDurability = 'ephemeral' | 'durable';
+interface AnchorDecayPolicy {
+    /** Days before an untouched active anchor transitions to sleeping */
+    activeDays: number;
+    /** Days an anchor remains sleeping before dropping to graveyard */
+    sleepDays: number;
+    /** Total maximum days before permanent graveyard sweep (9999 = never) */
+    graveyardDays: number;
+}
+interface AnchorEvidence {
+    settledAt?: number;
+    settledBy?: 'one-tap-settlement' | 'manual-command' | 'verification-test';
+    commitHash?: string;
+    summary?: string;
+    touchedFiles?: string[];
+}
+interface Anchor {
+    /** Unique sequential identifier, e.g., 'anc-1' */
+    id: string;
+    /** Short imperative title of the task */
+    title: string;
+    /** Optional detailed context or notes */
+    description?: string;
+    /** Task priority */
+    priority: AnchorPriority;
+    /** Current lifecycle status */
+    status: AnchorStatus;
+    /** Durability tier: ephemeral (short-lived reminder, 48h TTL) or durable (long-term architecture vision) */
+    durability: AnchorDurability;
+    /** Canonical project name (e.g. 'PPT', 'X', or 'global') */
+    project: string;
+    /** Canonical root directory where the task was anchored (empty string for global tasks) */
+    cwd: string;
+    /** Creation timestamp in ms */
+    createdAt: number;
+    /** Last update timestamp in ms */
+    updatedAt: number;
+    /** Last touched timestamp in ms (resets on file touch) */
+    lastTouchedAt: number;
+    /** Associated file paths or globs, e.g. ['src/auth/*.ts'] */
+    files: string[];
+    /** Expected completion date in format 'YYYY-MM-DD' (e.g. '2026-09-24') */
+    targetDate?: string;
+    /** Optional shell command for automated physical verification (e.g. 'npm test') */
+    verifyCommand?: string;
+    /** Topic or domain tags, e.g. ['auth', 'security'] */
+    tags: string[];
+    /** Optional recurrence pattern: 'daily' for recurring daily habits */
+    recurrence?: 'daily';
+    /** Last completed date string 'YYYY-MM-DD' for recurring tasks */
+    lastCompletedDate?: string;
+    /** Decay policy overrides */
+    decay: AnchorDecayPolicy;
+    /** Settlement evidence metadata upon closure */
+    evidence?: AnchorEvidence;
+}
+interface AnchorStoreState {
+    version: number;
+    anchors: Anchor[];
+    lastSweepAt: number;
+    nextId?: number;
+}
+interface TouchMatchResult {
+    anchor: Anchor;
+    score: number;
+    matchedFiles: string[];
+    reason: 'exact-file' | 'dir-prefix' | 'tag-keyword';
+}
+interface SettlementProposal {
+    anchor: Anchor;
+    matchedFiles: string[];
+    reason: string;
+    recommendedAction: 'settle' | 'defer';
+}
+declare const EPHEMERAL_DECAY_POLICY: AnchorDecayPolicy;
+declare const DURABLE_DECAY_POLICY: AnchorDecayPolicy;
+declare const DEFAULT_DECAY_POLICY: AnchorDecayPolicy;
+
+/**
+ * Detect whether a task is a short-term ephemeral reminder or a long-term architectural vision
+ */
+declare function detectDurability(title: string): AnchorDurability;
+/**
+ * Get custom ephemeral decay policy based on temporal span.
+ * Note: graveyardDays is always 9999 so unfinished tasks are NEVER silently deleted.
+ */
+declare function getEphemeralDecayPolicy(title: string): AnchorDecayPolicy;
+/**
+ * Detect expected completion date from title keywords or explicit date string, returning 'YYYY-MM-DD'
+ */
+declare function detectTargetDate(titleOrDate: string, now?: number): string | undefined;
+/**
+ * Detect recurring patterns, e.g. daily habits
+ */
+declare function detectRecurrence(title: string): 'daily' | undefined;
+/**
+ * Get current date string 'YYYY-MM-DD' in local timezone
+ */
+declare function getTodayDateString(timestamp?: number): string;
+/**
+ * Resolve the default storage directory for Anchor (~/.anchor).
+ * Hierarchy:
+ * 1. Process environment: ANCHOR_DIR
+ * 2. Canonical user-global store: ~/.anchor/
+ * 3. Legacy Pi harness fallback: ~/.pi/agent/anchors/ (migrates automatically if present)
+ */
+declare function getDefaultStorageDir(): string;
+/**
+ * Acquire exclusive lockfile using atomic 'wx' file creation (zero external dependencies).
+ * Features:
+ * - 0 async infection (100% synchronous)
+ * - Automatic stale lock eviction (>5000ms or dead PID)
+ * - Exponential backoff with jitter
+ */
+declare function acquireSyncLock(lockPath: string, maxWaitMs?: number, staleTimeoutMs?: number): () => void;
+/**
+ * Windows-tolerant atomic rename with exponential spin-retry to combat NTFS EBUSY/EPERM file locks
+ */
+declare function atomicRenameWithRetry(tempPath: string, targetPath: string, maxAttempts?: number): void;
+declare class AnchorStore {
+    readonly storageDir: string;
+    readonly statePath: string;
+    readonly archivePath: string;
+    readonly graveyardPath: string;
+    constructor(customStorageDir?: string);
+    get lockPath(): string;
+    /**
+     * Execute mutation within a cross-process exclusive lock
+     */
+    withLock<T>(fn: () => T): T;
+    private ensureDirs;
+    /**
+     * Load store state. If corrupt or missing, returns safe default.
+     */
+    loadState(): AnchorStoreState;
+    /**
+     * Atomically save store state via temp file + atomic rename with Windows NTFS spin-retry
+     */
+    saveState(state: AnchorStoreState): void;
+    private generateId;
+    /**
+     * Create a new Anchor with automatic project and cwd tagging
+     */
+    create(input: {
+        title: string;
+        description?: string;
+        priority?: AnchorPriority;
+        durability?: AnchorDurability;
+        recurrence?: 'daily';
+        cwd?: string;
+        project?: string;
+        targetDate?: string;
+        files?: string[];
+        tags?: string[];
+        verifyCommand?: string;
+        decay?: AnchorDecayPolicy;
+    }): Anchor;
+    private findAnchorIndex;
+    /**
+     * Get an anchor by ID (supports 'anc-1', '#anc-1', '1', '01')
+     */
+    get(id: string): Anchor | undefined;
+    /**
+     * 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?: {
+        status?: AnchorStatus;
+        priority?: AnchorPriority;
+        cwd?: string;
+        all?: boolean;
+        now?: number;
+    }): Anchor[];
+    /**
+     * Update an existing anchor
+     */
+    update(id: string, patch: Partial<Omit<Anchor, 'id' | 'createdAt'>>): Anchor;
+    /**
+     * Touch an anchor to refresh its decay window and reactivate sleeping state
+     */
+    touch(id: string, timestamp?: number): Anchor;
+    /**
+     * Settle an anchor (recurring daily habits complete for today and wake up tomorrow)
+     */
+    settle(id: string, evidence?: AnchorEvidence, now?: number): Anchor;
+    /**
+     * Reverse/undo the last settled anchor, popping it from archive.jsonl back into state.json
+     */
+    undoSettle(): Anchor;
+    /**
+     * Evict anchor to graveyard.jsonl upon total decay expiry
+     */
+    dropToGraveyard(id: string, reason: string): Anchor;
+    getArchive(filter?: {
+        cwd?: string;
+        all?: boolean;
+    }): Anchor[];
+    getGraveyard(filter?: {
+        cwd?: string;
+        all?: boolean;
+    }): Anchor[];
+}
+
+export { AnchorStore as A, DEFAULT_DECAY_POLICY as D, EPHEMERAL_DECAY_POLICY as E, type SettlementProposal as S, type TouchMatchResult as T, type AnchorStatus as a, type Anchor as b, type AnchorDecayPolicy as c, type AnchorDurability as d, type AnchorEvidence as e, type AnchorPriority as f, type AnchorStoreState as g, DURABLE_DECAY_POLICY as h, acquireSyncLock as i, atomicRenameWithRetry as j, detectDurability as k, detectRecurrence as l, detectTargetDate as m, getDefaultStorageDir as n, getEphemeralDecayPolicy as o, getTodayDateString as p };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-anchor",
-  "version": "0.2.3",
-  "description": "Cross-session task memory for Pi — pin tasks and reminders across terminal restarts with 0 git repo pollution, 0 idle tokens, and automatic completion on code changes.",
+  "version": "0.3.0",
+  "description": "Compact, autonomous, persistent task memory for Pi — pin tasks across sessions (/pin), auto-wake on project/file touch, and auto-settle in real time on git commit with 0 TODO.md clutter.",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -10,6 +10,7 @@
     "dist",
     "src",
     "bin",
+    "assets",
     "README.md",
     "README_zh.md",
     "LICENSE"
@@ -31,13 +32,28 @@
   },
   "keywords": [
     "pi-package",
-    "ai-agent",
-    "coding-agent",
+    "pi-extension",
+    "anchor",
+    "pi-anchor",
+    "todo",
+    "todos",
+    "tasks",
     "task-management",
+    "reminder",
+    "reminders",
     "memory",
+    "session",
+    "session-memory",
+    "handoff",
+    "persistence",
+    "checkpoint",
+    "resume",
+    "plan",
+    "roadmap",
     "context-window",
     "zero-pollution",
-    "pi-extension"
+    "ai-agent",
+    "coding-agent"
   ],
   "author": "Jason Song <jiaxinsong312@gmail.com>",
   "license": "MIT",

package/src/extension.ts

@@ -1,18 +1,84 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { Type } from '@sinclair/typebox';
-import { AnchorStore } from './store.ts';
+import { AnchorStore, detectTargetDate } from './store.ts';
 import { SessionTouchObserver } from './observer.ts';
 import { renderColdStartAnchorsContext, renderActiveAnchorsContext, makeSafeTaskAnnotation } from './context_injector.ts';
-import { generateSettlementProposals, runPhysicalVerification } from './settlement.ts';
-import { normalizePath, isSameOrSubPath, findMatchedAnchors } from './matcher.ts';
+import { generateSettlementProposals, runPhysicalVerification, tryRealtimeAutoSettle } from './settlement.ts';
+import { normalizePath, isSameOrSubPath, findMatchedAnchors, isAnchorTargetingWorkspace } from './matcher.ts';
 import { sweepStore } from './decay.ts';
-import { updateAnchorStatusBar, openAnchorDashboard, updateStartupBanner, truncateToWidth, hasActiveUI } from './tui.ts';
+import { updateAnchorStatusBar, openAnchorDashboard, updateStartupBanner, truncateToWidth, hasActiveUI, sortAnchorsForDisplay } from './tui.ts';
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
 const MUTATION_TOOLS = new Set(['edit', 'write', 'patch', 'apply_diff', 'create_file', 'modify']);
 
+/**
+ * Parse inline `--due <date>` / `-d <date>` flags and `done`/`rm`/`close`/`settle` subcommands
+ * for `/anchor` and `/pin` slash commands.
+ */
+export function parseAnchorCommandInput(raw: string, now: number = Date.now()): {
+  mode: 'dashboard' | 'undo' | 'settle' | 'pin';
+  targetId?: string;
+  title?: string;
+  targetDate?: string;
+} {
+  const trimmed = (raw || '').trim();
+  if (!trimmed || trimmed === 'list' || trimmed === 'ls') {
+    return { mode: 'dashboard' };
+  }
+  if (trimmed === 'undo') {
+    return { mode: 'undo' };
+  }
+
+  // Match explicit settle subcommands: `/anchor done 1`, `/anchor rm anc-2`, `/anchor settle #1`
+  const settleMatch = trimmed.match(/^(?:done|rm|close|settle)\s+(.+)$/i);
+  if (settleMatch) {
+    return {
+      mode: 'settle',
+      targetId: settleMatch[1].trim().replace(/^#/, '')
+    };
+  }
+
+  // Extract optional `--due <val>` or `-d <val>` flag
+  let targetDate: string | undefined;
+  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
+  };
+}
+
+/**
+ * Resolve either an explicit anchor ID ('anc-2', '2') or a 1-based visual dashboard index ('01', '1')
+ */
+export function resolveAnchorTarget(store: AnchorStore, idOrIndex: string, cwd?: string): string | undefined {
+  const clean = idOrIndex.trim().replace(/^#/, '');
+  // 1. Check 1-based sequential index from the sorted display list first when user passes a plain number
+  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;
+    }
+  }
+  // 2. Fallback to direct ID lookup in store
+  const direct = store.get(clean);
+  return direct?.id;
+}
+
 export default function (pi: ExtensionAPI) {
   // Global authoritative store in ~/.anchor/ (0 workspace clutter)
   const store = new AnchorStore();
@@ -28,8 +94,16 @@ export default function (pi: ExtensionAPI) {
 
     const sweep = sweepStore(store);
 
-    if (sweep.transitionedToSleeping.length > 0) {
-      ctx.ui.notify(`Anchor: ${sweep.transitionedToSleeping.length} 个非活跃任务已进入休眠`, 'info');
+    // Smart Workspace Wakeup: if a sleeping anchor specifically targets the workspace we just opened, wake it automatically!
+    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(`⌖ Anchor: ${sweep.transitionedToSleeping.length} inactive task(s) moved to quiet mode (/anchor to view)`, 'info');
     }
 
     // Physical Pre-flight Verification: auto-settle passing tasks or record failing output (scoped strictly to current cwd)
@@ -43,7 +117,7 @@ export default function (pi: ExtensionAPI) {
               settledBy: 'verification-test',
               summary: `Physical pre-flight test passed: ${a.verifyCommand}`
             });
-            ctx.ui.notify(`⚓ 物理验证通过！锚点 #${a.id} ("${a.title}") 已自动结案归档。`, 'info');
+            ctx.ui.notify(`⌖ Verification passed! Auto-settled #${a.id}: "${a.title}"`, 'info');
           } else {
             preflightFailures.set(a.id, res.output.slice(-250));
           }
@@ -104,11 +178,31 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // 4. JIT Path-Triggered Context Alert: When agent successfully touches an intersecting file
+  // 4. JIT Path-Triggered Context Alert & Real-Time Autonomous Commit/Test Settlement
   pi.on('tool_result', async (event: any, ctx: ExtensionContext) => {
+    const lowerTool = String(event.toolName || '').toLowerCase();
+
     // Only verified, non-error tool executions are recorded to prevent false-positive settlement
     if (!event.isError) {
       observer.recordToolCall(event.toolName, event.input || {});
+
+      // Real-time autonomous settlement on git commit or passing verifyCommand!
+      if (lowerTool === 'bash' || lowerTool === 'powershell') {
+        const executedCmd = String((event.input as any)?.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(`⌖ Auto-settled #${item.anchor.id} ("${item.anchor.title}") via ${item.reason}`, 'info');
+                } catch {}
+              }
+            }
+          }
+        }
+      }
     }
 
     const pathInput = (event.input as any)?.path;
@@ -189,9 +283,9 @@ export default function (pi: ExtensionAPI) {
     }
 
     const modified = observer.getModifiedFiles();
-    if (modified.length === 0) return;
+    if (modified.length === 0 && !observer.hasCommitted()) return;
 
-    const proposals = generateSettlementProposals(store, modified, ctx.cwd);
+    const proposals = generateSettlementProposals(store, modified, ctx.cwd, observer);
     if (proposals.length === 0) return;
 
     // Check proposals for automated verification or one-tap settlement
@@ -416,20 +510,20 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // 6. User Slash Commands: /anchor and /pin
+  // 6. User Slash Commands: /anchor, /pin, and /done
   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: string, ctx: ExtensionContext) => {
-      const input = (args || '').trim();
+      const parsed = parseAnchorCommandInput(args);
 
       // Case 1: View active anchors (clean list, enter to complete)
-      if (!input || input === 'list' || input === 'ls') {
+      if (parsed.mode === 'dashboard') {
         await openAnchorDashboard(ctx, store);
         return;
       }
 
       // Case 2: Revert settlement
-      if (input === 'undo') {
+      if (parsed.mode === 'undo') {
         try {
           const restored = store.undoSettle();
           ctx.ui.notify(`⌖ Restored #${restored.id}: "${restored.title}"`, 'info');
@@ -440,34 +534,77 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      // Case 3: Complete directly by ID (e.g. /anchor anc-1)
-      const targetId = input.startsWith('#') ? input.slice(1) : input;
-      const item = store.get(targetId);
-      if (item) {
-        store.settle(targetId, { settledBy: 'manual-command' });
-        ctx.ui.notify(`⌖ Settled: "${item.title}"`, 'info');
+      // Case 3: Explicit settle subcommand (`/anchor done 1` or `/anchor done anc-1`)
+      if (parsed.mode === 'settle' && parsed.targetId) {
+        const resolvedId = resolveAnchorTarget(store, parsed.targetId, ctx.cwd);
+        if (!resolvedId) {
+          ctx.ui.notify(`⌖ Anchor not found: ${parsed.targetId}`, 'error');
+          return;
+        }
+        const settled = store.settle(resolvedId, { settledBy: 'manual-command' });
+        ctx.ui.notify(`⌖ Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, 'info');
         updateAnchorStatusBar(ctx, store);
         return;
       }
 
-      // Case 4: Freeform text directly creates an anchor
-      const anc = store.create({ title: input, cwd: ctx.cwd });
-      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"`, 'info');
+      // Case 4: Direct ID completion if input matches an existing ID (e.g. `/anchor anc-1` or `/anchor #1`)
+      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(`⌖ Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, 'info');
+          updateAnchorStatusBar(ctx, store);
+          return;
+        }
+      }
+
+      // Case 5: Freeform text creates an anchor (supports `--due <date>`)
+      const anc = store.create({
+        title: parsed.title || rawTrimmed,
+        targetDate: parsed.targetDate,
+        cwd: ctx.cwd
+      });
+      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ''}`, 'info');
       updateAnchorStatusBar(ctx, store);
     }
   });
 
-  // Alias /pin to instant-add
+  // Alias /pin to instant-add (supports `--due <date>`)
   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: string, ctx: ExtensionContext) => {
+      const parsed = parseAnchorCommandInput(args);
+      if (parsed.mode === 'dashboard' || !parsed.title) {
+        await openAnchorDashboard(ctx, store);
+        return;
+      }
+      const anc = store.create({
+        title: parsed.title,
+        targetDate: parsed.targetDate,
+        cwd: ctx.cwd
+      });
+      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"${anc.targetDate ? ` (due ${anc.targetDate})` : ''}`, 'info');
+      updateAnchorStatusBar(ctx, store);
+    }
+  });
+
+  // Alias /done for 1-step completion by display number or ID (e.g. `/done 1`)
+  pi.registerCommand('done', {
+    description: 'Complete an active anchor by row number or ID (e.g. /done 1)',
     handler: async (args: string, ctx: ExtensionContext) => {
-      const title = (args || '').trim();
-      if (!title) {
+      const target = (args || '').trim();
+      if (!target) {
         await openAnchorDashboard(ctx, store);
         return;
       }
-      const anc = store.create({ title, cwd: ctx.cwd });
-      ctx.ui.notify(`⌖ Pinned #${anc.id}: "${anc.title}"`, 'info');
+      const resolvedId = resolveAnchorTarget(store, target, ctx.cwd);
+      if (!resolvedId) {
+        ctx.ui.notify(`⌖ Anchor not found: ${target}`, 'error');
+        return;
+      }
+      const settled = store.settle(resolvedId, { settledBy: 'manual-command' });
+      ctx.ui.notify(`⌖ Settled #${settled.id}: "${settled.title}" (/anchor undo to revert)`, 'info');
       updateAnchorStatusBar(ctx, store);
     }
   });

package/src/matcher.ts

@@ -51,6 +51,57 @@ export function isSameOrSubPath(anchorCwd?: string, targetCwd?: string): boolean
   return cmpA === cmpT || cmpT.startsWith(cmpA + '/') || cmpA.startsWith(cmpT + '/');
 }
 
+/**
+ * Extract explicit file or directory paths mentioned in natural language title/description
+ * (e.g. "D:/College/优化/EXTERNAL_ARCHITECTURE_INSPIRATIONS.md", "src/auth/jwt.ts")
+ */
+export function extractPathsFromText(text?: string): string[] {
+  if (!text) return [];
+  const results = new Set<string>();
+  // Match absolute Windows/POSIX paths or relative project paths with extensions/slashes
+  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: RegExpExecArray | null;
+  while ((match = regex.exec(text)) !== null) {
+    const cleaned = normalizePath(match[0].replace(/[.:;,'")\]}>]+$/, ''));
+    if (cleaned && cleaned.length >= 3) {
+      results.add(cleaned);
+    }
+  }
+  return Array.from(results);
+}
+
+/**
+ * Determine whether an anchor specifically targets a given workspace directory (`targetCwd`),
+ * checking `anchor.cwd`, `anchor.project`, and `anchor.files`.
+ */
+export function isAnchorTargetingWorkspace(anchor: Anchor, targetCwd?: string): boolean {
+  if (!targetCwd) return true;
+  const normTarget = targetCwd.trim().replace(/\\/g, '/').replace(/\/+$/, '');
+  const targetBase = path.basename(normTarget).toLowerCase();
+
+  // 1. Check explicit project path or project folder name
+  if (anchor.project && anchor.project !== 'global') {
+    const normProj = anchor.project.trim().replace(/\\/g, '/').replace(/\/+$/, '');
+    if (isSameOrSubPath(normProj, normTarget)) return true;
+    const projBase = path.basename(normProj).toLowerCase();
+    if (projBase && projBase === targetBase) return true;
+  }
+
+  // 2. Check associated file paths
+  if (anchor.files && anchor.files.length > 0) {
+    for (const f of anchor.files) {
+      if (isSameOrSubPath(f, normTarget)) return true;
+    }
+  }
+
+  // 3. Check creation cwd (only if files are relative or empty, or if no conflicting absolute project path was given)
+  if (anchor.cwd && isSameOrSubPath(anchor.cwd, normTarget)) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Match touched files against an anchor's registered physical patterns
  * Only anchors with explicit files/globs/prefixes are matched against file touches.