pi-anchor 0.2.3 → 0.3.0

package/src/settlement.ts

@@ -1,5 +1,6 @@
 import type { AnchorStore } from './store.ts';
-import { findMatchedAnchors } from './matcher.ts';
+import { findMatchedAnchors, isAnchorTargetingWorkspace } from './matcher.ts';
+import type { SessionTouchObserver } from './observer.ts';
 import type { Anchor, SettlementProposal } from './types.ts';
 import { execSync } from 'node:child_process';
 
@@ -27,31 +28,96 @@ export function runPhysicalVerification(anchor: Anchor, cwd: string): { success:
 }
 
 /**
- * Generate settlement candidates based on files touched during the session
+ * Real-time autonomous settlement during active session:
+ * Triggered immediately when a non-error shell command runs `git commit` or a matching `verifyCommand`.
+ * Works for BOTH file-bound and file-less (`files: []`) anchors!
+ */
+export function tryRealtimeAutoSettle(
+  store: AnchorStore,
+  observer: SessionTouchObserver,
+  cwd?: string,
+  executedCommand?: string
+): Array<{ anchor: Anchor; reason: string }> {
+  const candidates = store.list({ cwd }).filter(a => a.status === 'active' || a.status === 'sleeping');
+  if (candidates.length === 0) return [];
+
+  const settledList: Array<{ anchor: Anchor; reason: string }> = [];
+  const cmdTrimmed = (executedCommand || '').trim();
+
+  for (const a of candidates) {
+    // 1. Check real-time Git Commit semantic match (works even when a.files is empty!)
+    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;
+      }
+    }
+
+    // 2. Check if the executed shell command directly ran and passed the anchor's verifyCommand
+    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;
+}
+
+/**
+ * Generate settlement candidates based on files touched or commits made during the session
  */
 export function generateSettlementProposals(
   store: AnchorStore,
   touchedFiles: string[],
-  cwd?: string
+  cwd?: string,
+  observer?: SessionTouchObserver
 ): SettlementProposal[] {
-  // Only match active/sleeping anchors belonging to current workspace
   const activeAndSleeping = store.list({ cwd }).filter(a => a.status === 'active' || a.status === 'sleeping');
   const matches = findMatchedAnchors(activeAndSleeping, touchedFiles);
+  const seenIds = new Set<string>();
 
   const proposals: SettlementProposal[] = [];
 
   for (const match of matches) {
+    seenIds.add(match.anchor.id);
     const fileList = match.matchedFiles.slice(0, 3).join(', ');
-    const moreSuffix = match.matchedFiles.length > 3 ? ` 等 ${match.matchedFiles.length} 个文件` : '';
+    const moreSuffix = match.matchedFiles.length > 3 ? ` (+${match.matchedFiles.length - 3} more)` : '';
 
     proposals.push({
       anchor: match.anchor,
       matchedFiles: match.matchedFiles,
-      reason: `本次会话修改了 ${fileList}${moreSuffix}`,
+      reason: `Modified ${fileList}${moreSuffix}`,
       recommendedAction: match.score >= 0.85 ? 'settle' : 'defer'
     });
   }
 
+  // Also include file-less (or un-matched) anchors if a git commit message matched them
+  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;
 }
 

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, isSameOrSubPath } from './matcher.ts';
+import { normalizePath, isSameOrSubPath, extractPathsFromText, isAnchorTargetingWorkspace } from './matcher.ts';
 
 /**
  * Detect whether a task is a short-term ephemeral reminder or a long-term architectural vision
@@ -31,15 +31,16 @@ export function detectDurability(title: string): AnchorDurability {
 }
 
 /**
- * Get custom ephemeral decay policy based on temporal span (e.g. 后天, 大后天)
+ * Get custom ephemeral decay policy based on temporal span.
+ * Note: graveyardDays is always 9999 so unfinished tasks are NEVER silently deleted.
  */
 export function getEphemeralDecayPolicy(title: string): AnchorDecayPolicy {
   const lower = title.toLowerCase();
   if (lower.includes('大后天')) {
-    return { activeDays: 3, sleepDays: 1, graveyardDays: 4 };
+    return { activeDays: 7, sleepDays: 30, graveyardDays: 9999 };
   }
   if (lower.includes('后天')) {
-    return { activeDays: 2, sleepDays: 1, graveyardDays: 3 };
+    return { activeDays: 7, sleepDays: 30, graveyardDays: 9999 };
   }
   return { ...EPHEMERAL_DECAY_POLICY };
 }
@@ -415,7 +416,22 @@ export class AnchorStore {
       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 project is an explicit absolute path (e.g. "D:/College/优化"), align cwd to it so workspace matching is never split
+      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 = path.dirname(inferredFiles[0]);
+        if (firstDir && firstDir !== '.') {
+          cwd = normalizePath(firstDir);
+        }
+      }
+
       const projectName = input.project
         ? input.project.trim()
         : (cwd ? path.basename(cwd) : 'global');
@@ -442,7 +458,7 @@ export class AnchorStore {
         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() || undefined,
         decay: input.decay ? { ...input.decay } : { ...decayPolicy }
@@ -497,10 +513,10 @@ export class AnchorStore {
       if (filter?.priority && a.priority !== filter.priority) return false;
 
       // Project context filtering:
-      // 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 an anchor has specific code files attached, match against cwd, project path/name, or file paths.
+      // If an anchor has NO code files attached (general tasks, memos), it is universal and visible everywhere!
       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;
         }
       }

package/src/tui.ts

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { AnchorStore, getTodayDateString } from './store.ts';
+import { isAnchorTargetingWorkspace } from './matcher.ts';
 import type { Anchor } from './types.ts';
 import path from 'node:path';
 
@@ -57,6 +58,40 @@ export function groupAnchorsByQuadrant(anchors: Anchor[], now: number = Date.now
   return groups;
 }
 
+const PRIORITY_RANK: Record<string, number> = { p0: 0, p1: 1, p2: 2 };
+
+/**
+ * Sort unfinished anchors into a single compact, priority-driven engineering list:
+ * 1. Active before Sleeping (quiet)
+ * 2. Matching current workspace before other workspaces
+ * 3. Due Today / Overdue before open-ended
+ * 4. Priority (P0 -> P1 -> P2)
+ */
+export function sortAnchorsForDisplay(anchors: Anchor[], cwd?: string, now: number = Date.now()): Anchor[] {
+  const todayStr = getTodayDateString(now);
+  return [...anchors].sort((a, b) => {
+    // 1. Active before sleeping
+    if (a.status !== b.status) {
+      return a.status === 'active' ? -1 : 1;
+    }
+    // 2. Current workspace match first
+    if (cwd) {
+      const aMatch = isAnchorTargetingWorkspace(a, cwd) ? 0 : 1;
+      const bMatch = isAnchorTargetingWorkspace(b, cwd) ? 0 : 1;
+      if (aMatch !== bMatch) return aMatch - bMatch;
+    }
+    // 3. Due today / overdue first
+    const aDue = a.targetDate && a.targetDate <= todayStr ? 0 : 1;
+    const bDue = b.targetDate && b.targetDate <= todayStr ? 0 : 1;
+    if (aDue !== bDue) return aDue - bDue;
+    // 4. Priority P0 -> P1 -> P2
+    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;
+  });
+}
+
 const ANSI_REGEX = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
 
 /**
@@ -286,15 +321,23 @@ export function formatRemainingTtl(anchor: Anchor, now: number = Date.now()): st
 }
 
 /**
- * Format origin creation workspace folder (provenance: where the task was born/created)
+ * Format origin workspace / project label concisely
  */
 export function formatOrigin(anchor: Anchor | string): string {
   if (typeof anchor === 'object') {
-    if (!anchor.cwd) return anchor.project || 'global';
-    return path.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 path.basename(anchor.cwd.replace(/\\/g, '/')) || 'global';
   }
   if (!anchor) return 'global';
-  return path.basename(anchor) || 'global';
+  return path.basename(anchor.replace(/\\/g, '/')) || 'global';
 }
 
 /**
@@ -372,7 +415,7 @@ export function updateStartupBanner(ctx: ExtensionContext, store: AnchorStore):
 }
 
 /**
- * Clean, columnar-aligned checklist with Target Date and Creation Time columns
+ * Clean, flat priority-sorted engineering checklist (includes both active and quiet/sleeping tasks so nothing is ever lost)
  */
 export async function openAnchorDashboard(
   ctx: ExtensionContext,
@@ -380,66 +423,67 @@ export async function openAnchorDashboard(
 ): Promise<void> {
   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('⌖ 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 = new Map<string, Anchor>();
   const displayOptions: string[] = [];
   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;
 
-    // Clean tabular column alignment: ID, Category, Title, Project, Target, Created
     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();
+      ? `${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('⌖ Anchors (select to inspect or settle):', displayOptions);
+  const selected = await ctx.ui.select('⌖ Anchors (select to settle, wake, or inspect):', displayOptions);
   if (!selected) return;
 
   const anchor = optionMap.get(selected);
   if (!anchor) return;
 
+  const actions = [
+    '✓ Settle (Mark completed and archive)',
+    ...(anchor.status === 'sleeping' ? ['⚡ Wake up (Activate for current session)'] : []),
+    'ℹ View details & associated files',
+    '↩ Cancel'
+  ];
+
   const action = await ctx.ui.select(
     `⌖ Anchor #${anchor.id}: "${anchor.title}"`,
-    [
-      '✓ Settle (Mark completed and archive)',
-      'ℹ View details & associated files',
-      '↩ Cancel'
-    ]
+    actions
   );
   if (!action || action.startsWith('↩')) return;
 
@@ -450,9 +494,13 @@ export async function openAnchorDashboard(
       : `⌖ Settled #${anchor.id}: "${anchor.title}" (/anchor undo to revert)`;
     ctx.ui.notify(successMsg, 'info');
     updateAnchorStatusBar(ctx, store);
+  } else if (action.startsWith('⚡')) {
+    store.touch(anchor.id);
+    ctx.ui.notify(`⌖ Woke up #${anchor.id}: "${anchor.title}"`, 'info');
+    updateAnchorStatusBar(ctx, store);
   } else if (action.startsWith('ℹ')) {
     const details = [
-      `#${anchor.id} [${anchor.priority.toUpperCase()}] ${anchor.title}`,
+      `#${anchor.id} [${anchor.priority.toUpperCase()} · ${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,

package/src/types.ts

@@ -87,19 +87,19 @@ export interface SettlementProposal {
 }
 
 export const EPHEMERAL_DECAY_POLICY: AnchorDecayPolicy = {
-  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
 };
 
 export const DURABLE_DECAY_POLICY: AnchorDecayPolicy = {
-  activeDays: 3,
+  activeDays: 7,      // 7 days active before quiet sleep
   sleepDays: 30,
   graveyardDays: 9999 // Never permanently auto-dropped; preserved indefinitely
 };
 
 export const DEFAULT_DECAY_POLICY: AnchorDecayPolicy = {
-  activeDays: 3,
-  sleepDays: 7,
-  graveyardDays: 14
+  activeDays: 7,
+  sleepDays: 30,
+  graveyardDays: 9999
 };