@tekmidian/pai 0.5.5 → 0.5.7

package/src/hooks/ts/lib/project-utils.ts

@@ -10,10 +10,29 @@
 
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
 import { join, basename } from 'path';
+import { homedir } from 'os';
 
 // Import from pai-paths which handles .env loading and path resolution
 import { PAI_DIR } from './pai-paths.js';
 
+/**
+ * Directories known to be automated health-check / probe sessions.
+ * Hooks should exit early for these to avoid registry clutter and wasted work.
+ */
+const PROBE_CWD_PATTERNS = [
+  '/CodexBar/ClaudeProbe',
+  '/ClaudeProbe',
+];
+
+/**
+ * Check if the current working directory belongs to a probe/health-check session.
+ * Returns true if hooks should skip this session entirely.
+ */
+export function isProbeSession(cwd?: string): boolean {
+  const dir = cwd || process.cwd();
+  return PROBE_CWD_PATTERNS.some(pattern => dir.includes(pattern));
+}
+
 // Re-export PAI_DIR for consumers
 export { PAI_DIR };
 export const PROJECTS_DIR = join(PAI_DIR, 'projects');
@@ -96,20 +115,20 @@ export function getSessionsDirFromProjectDir(projectDir: string): string {
 }
 
 /**
- * Check if WhatsApp (Whazaa) is configured as an enabled MCP server.
+ * Check if a messaging MCP server (AIBroker, Whazaa, or Telex) is configured.
  *
  * Uses standard Claude Code config at ~/.claude/settings.json.
- * No PAI dependency — works for any Claude Code user with whazaa installed.
+ * When any messaging server is active, the AI handles notifications via MCP
+ * and ntfy is skipped to avoid duplicates.
  */
 export function isWhatsAppEnabled(): boolean {
   try {
-    const { homedir } = require('os');
     const settingsPath = join(homedir(), '.claude', 'settings.json');
     if (!existsSync(settingsPath)) return false;
 
     const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
     const enabled: string[] = settings.enabledMcpjsonServers || [];
-    return enabled.includes('whazaa');
+    return enabled.includes('aibroker') || enabled.includes('whazaa') || enabled.includes('telex');
   } catch {
     return false;
   }
@@ -967,7 +986,7 @@ export function updateTodoContinue(
   const now = new Date().toISOString();
   const stateLines = state
     ? state.split('\n').filter(l => l.trim()).slice(0, 10).map(l => `> ${l}`).join('\n')
-    : `> Check the latest session note for details.`;
+    : `> Working directory: ${cwd}. Check the latest session note for details.`;
 
   const continueSection = `## Continue
 

package/src/hooks/ts/pre-compact/context-compression-hook.ts

@@ -7,11 +7,13 @@
  * 2. Update TODO.md with a proper ## Continue section for the next session
  * 3. Save session state to temp file for post-compact injection via SessionStart(compact)
  *
- * This hook now mirrors "pause session" behavior: the session note gets a
- * descriptive name, rich content, and TODO.md gets a continuation prompt.
+ * Uses a CUMULATIVE state file (.compact-state.json) that persists across
+ * compactions. This ensures that even after multiple compactions (where the
+ * transcript becomes thin), we still have rich data for titles, summaries,
+ * and work items from earlier in the session.
  */
 
-import { readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { basename, dirname, join } from 'path';
 import { tmpdir } from 'os';
 import {
@@ -24,6 +26,7 @@ import {
   renameSessionNote,
   updateTodoContinue,
   calculateSessionTokens,
+  isProbeSession,
   WorkItem,
 } from '../lib/project-utils';
 
@@ -276,11 +279,75 @@ function deriveTitle(data: TranscriptData): string {
     .substring(0, 60);
 }
 
+// ---------------------------------------------------------------------------
+// Cumulative state — persists across compactions in .compact-state.json
+// ---------------------------------------------------------------------------
+
+const CUMULATIVE_STATE_FILE = '.compact-state.json';
+
+function loadCumulativeState(notesDir: string): TranscriptData | null {
+  try {
+    const filePath = join(notesDir, CUMULATIVE_STATE_FILE);
+    if (!existsSync(filePath)) return null;
+    const raw = JSON.parse(readFileSync(filePath, 'utf-8'));
+    return {
+      userMessages: raw.userMessages || [],
+      summaries: raw.summaries || [],
+      captures: raw.captures || [],
+      lastCompleted: raw.lastCompleted || '',
+      filesModified: raw.filesModified || [],
+      workItems: raw.workItems || [],
+    };
+  } catch {
+    return null;
+  }
+}
+
+function mergeTranscriptData(accumulated: TranscriptData | null, current: TranscriptData): TranscriptData {
+  if (!accumulated) return current;
+
+  const mergeArrays = (a: string[], b: string[]): string[] => {
+    const seen = new Set(a);
+    return [...a, ...b.filter(x => !seen.has(x))];
+  };
+
+  const seenTitles = new Set(accumulated.workItems.map(w => w.title));
+  const newWorkItems = current.workItems.filter(w => !seenTitles.has(w.title));
+
+  return {
+    userMessages: mergeArrays(accumulated.userMessages, current.userMessages).slice(-20),
+    summaries: mergeArrays(accumulated.summaries, current.summaries),
+    captures: mergeArrays(accumulated.captures, current.captures),
+    lastCompleted: current.lastCompleted || accumulated.lastCompleted,
+    filesModified: mergeArrays(accumulated.filesModified, current.filesModified),
+    workItems: [...accumulated.workItems, ...newWorkItems],
+  };
+}
+
+function saveCumulativeState(notesDir: string, data: TranscriptData, notePath: string | null): void {
+  try {
+    const filePath = join(notesDir, CUMULATIVE_STATE_FILE);
+    writeFileSync(filePath, JSON.stringify({
+      ...data,
+      notePath,
+      lastUpdated: new Date().toISOString(),
+    }, null, 2));
+    console.error(`Cumulative state saved (${data.workItems.length} work items, ${data.filesModified.length} files)`);
+  } catch (err) {
+    console.error(`Failed to save cumulative state: ${err}`);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
 
 async function main() {
+  // Skip probe/health-check sessions (e.g. CodexBar ClaudeProbe)
+  if (isProbeSession()) {
+    process.exit(0);
+  }
+
   let hookInput: HookInput | null = null;
 
   try {
@@ -311,10 +378,28 @@ async function main() {
       : String(tokenCount);
 
     // -----------------------------------------------------------------
-    // Single-pass transcript parsing
+    // Single-pass transcript parsing + cumulative state merge
     // -----------------------------------------------------------------
     const data = parseTranscript(hookInput.transcript_path);
-    const state = formatSessionState(data, hookInput.cwd);
+
+    // Find notes directory early — needed for cumulative state
+    let notesInfo: { path: string; isLocal: boolean };
+    try {
+      notesInfo = hookInput.cwd
+        ? findNotesDir(hookInput.cwd)
+        : { path: join(dirname(hookInput.transcript_path), 'Notes'), isLocal: false };
+    } catch {
+      notesInfo = { path: join(dirname(hookInput.transcript_path), 'Notes'), isLocal: false };
+    }
+
+    // Load accumulated state from previous compactions and merge
+    const accumulated = loadCumulativeState(notesInfo.path);
+    const merged = mergeTranscriptData(accumulated, data);
+    const state = formatSessionState(merged, hookInput.cwd);
+
+    if (accumulated) {
+      console.error(`Loaded cumulative state: ${accumulated.workItems.length} work items, ${accumulated.filesModified.length} files from previous compaction(s)`);
+    }
 
     // -----------------------------------------------------------------
     // Persist session state to numbered session note (like "pause session")
@@ -322,9 +407,6 @@ async function main() {
     let notePath: string | null = null;
 
     try {
-      const notesInfo = hookInput.cwd
-        ? findNotesDir(hookInput.cwd)
-        : { path: join(dirname(hookInput.transcript_path), 'Notes'), isLocal: false };
       notePath = getCurrentNotePath(notesInfo.path);
 
       // If no note found, or the latest note is completed, create a new one
@@ -347,14 +429,14 @@ async function main() {
         : `Context compression triggered at ~${tokenDisplay} tokens with ${stats.messageCount} messages.`;
       appendCheckpoint(notePath, checkpointBody);
 
-      // 2. Write work items to "Work Done" section
-      if (data.workItems.length > 0) {
-        addWorkToSessionNote(notePath, data.workItems, `Pre-Compact (~${tokenDisplay} tokens)`);
-        console.error(`Added ${data.workItems.length} work item(s) to session note`);
+      // 2. Write work items to "Work Done" section (uses merged cumulative data)
+      if (merged.workItems.length > 0) {
+        addWorkToSessionNote(notePath, merged.workItems, `Pre-Compact (~${tokenDisplay} tokens)`);
+        console.error(`Added ${merged.workItems.length} work item(s) to session note`);
       }
 
-      // 3. Rename session note with a meaningful title (instead of "New Session")
-      const title = deriveTitle(data);
+      // 3. Rename session note with a meaningful title (uses merged data for richer titles)
+      const title = deriveTitle(merged);
       if (title) {
         const newPath = renameSessionNote(notePath, title);
         if (newPath !== notePath) {
@@ -377,6 +459,9 @@ async function main() {
       console.error(`Could not save checkpoint: ${noteError}`);
     }
 
+    // Save cumulative state for next compaction
+    saveCumulativeState(notesInfo.path, merged, notePath);
+
     // -----------------------------------------------------------------
     // Update TODO.md with proper ## Continue section (like "pause session")
     // -----------------------------------------------------------------
@@ -397,13 +482,22 @@ async function main() {
     // Instead, we write the injection payload to a temp file keyed by
     // session_id. The SessionStart(compact) hook reads it and outputs
     // to stdout, which IS injected into the post-compaction context.
+    //
+    // Always fires (even with thin state) — includes note path so the AI
+    // can enrich the session note post-compaction using its own context.
     // -----------------------------------------------------------------------
-    if (state && hookInput.session_id) {
+    if (hookInput.session_id) {
+      const stateText = state || `Working directory: ${hookInput.cwd || 'unknown'}`;
+      const noteInfo = notePath
+        ? `\nSESSION NOTE: ${notePath}\nIf this note still has a generic title (e.g. "New Session", "Context Compression"),\nrename it based on actual work done and add a rich summary.`
+        : '';
+
       const injection = [
         '<system-reminder>',
         `SESSION STATE RECOVERED AFTER COMPACTION (${compactType}, ~${tokenDisplay} tokens)`,
         '',
-        state,
+        stateText,
+        noteInfo,
         '',
         'IMPORTANT: This session state was captured before context compaction.',
         'Use it to maintain continuity. Continue the conversation from where',

package/src/hooks/ts/session-start/initialize-session.ts

@@ -24,7 +24,7 @@ import { existsSync, statSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import { PAI_DIR } from '../lib/pai-paths';
-import { sendNtfyNotification, isWhatsAppEnabled } from '../lib/project-utils';
+import { sendNtfyNotification, isWhatsAppEnabled, isProbeSession } from '../lib/project-utils';
 
 // Debounce duration in milliseconds (prevents duplicate SessionStart events)
 const DEBOUNCE_MS = 2000;
@@ -111,6 +111,12 @@ async function main() {
       process.exit(0);
     }
 
+    // Skip probe/health-check sessions (e.g. CodexBar ClaudeProbe)
+    if (isProbeSession()) {
+      console.error('Probe session detected - skipping session initialization');
+      process.exit(0);
+    }
+
     // Check debounce to prevent duplicate notifications
     // (IDE extension can fire multiple SessionStart events)
     if (shouldDebounce()) {

package/src/hooks/ts/session-start/load-core-context.ts

@@ -28,6 +28,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { PAI_DIR, SKILLS_DIR } from '../lib/pai-paths';
+import { isProbeSession } from '../lib/project-utils';
 
 async function main() {
   try {
@@ -42,6 +43,12 @@ async function main() {
       process.exit(0);
     }
 
+    // Skip probe/health-check sessions (e.g. CodexBar ClaudeProbe)
+    if (isProbeSession()) {
+      console.error('Probe session detected - skipping CORE context loading');
+      process.exit(0);
+    }
+
     // Get CORE skill path using PAI paths library
     const coreSkillPath = join(SKILLS_DIR, 'CORE/SKILL.md');
 

package/src/hooks/ts/session-start/load-project-context.ts

@@ -27,7 +27,8 @@ import {
   createSessionNote,
   findTodoPath,
   findAllClaudeMdPaths,
-  sendNtfyNotification
+  sendNtfyNotification,
+  isProbeSession
 } from '../lib/project-utils';
 
 /**
@@ -80,6 +81,12 @@ interface HookInput {
 async function main() {
   console.error('\nload-project-context.ts starting...');
 
+  // Skip probe/health-check sessions (e.g. CodexBar ClaudeProbe)
+  if (isProbeSession()) {
+    console.error('Probe session detected - skipping project context loading');
+    process.exit(0);
+  }
+
   // Read hook input from stdin
   let hookInput: HookInput | null = null;
   try {

package/src/hooks/ts/stop/stop-hook.ts

@@ -9,6 +9,8 @@ import {
   moveSessionFilesToSessionsDir,
   addWorkToSessionNote,
   findNotesDir,
+  isProbeSession,
+  updateTodoContinue,
   WorkItem
 } from '../lib/project-utils';
 
@@ -207,6 +209,11 @@ function contentToText(content: any): string {
 }
 
 async function main() {
+  // Skip probe/health-check sessions (e.g. CodexBar ClaudeProbe)
+  if (isProbeSession()) {
+    process.exit(0);
+  }
+
   const timestamp = new Date().toISOString();
   console.error(`\nSTOP-HOOK TRIGGERED AT ${timestamp}`);
 
@@ -385,6 +392,27 @@ async function main() {
       const summary = message || 'Session completed.';
       finalizeSessionNote(currentNotePath, summary);
       console.error(`Session note finalized: ${basename(currentNotePath)}`);
+
+      // Update TODO.md ## Continue section so next session has context
+      try {
+        const stateLines: string[] = [];
+        stateLines.push(`Working directory: ${cwd}`);
+        if (workItems.length > 0) {
+          stateLines.push('');
+          stateLines.push('Work completed:');
+          for (const item of workItems.slice(0, 5)) {
+            stateLines.push(`- ${item.title}`);
+          }
+        }
+        if (message) {
+          stateLines.push('');
+          stateLines.push(`Last completed: ${message}`);
+        }
+        const state = stateLines.join('\n');
+        updateTodoContinue(cwd, basename(currentNotePath), state, 'session-end');
+      } catch (todoError) {
+        console.error(`Could not update TODO.md: ${todoError}`);
+      }
     }
   } catch (noteError) {
     console.error(`Could not finalize session note: ${noteError}`);

package/templates/claude-md.template.md

@@ -635,82 +635,13 @@ IMPORTANT:
 
 ---
 
-## MANDATORY: End Session Command
+## Session Lifecycle
 
-**When user says "end session", execute this COMPLETE procedure automatically.**
+**Session commands (pause, end, continue, go, cpp) are defined in the CORE skill.**
 
-### The End Session Checklist
+The CORE skill auto-loads at session start and contains the full session lifecycle: pause checkpoints, end session with commit/push, continuation protocol, and session note naming rules.
 
-```bash
-# 1. Update session notes with summary of work done
-# 2. Update TODO.md (mark completed, add discovered tasks)
-# 3. Rename session note if it has placeholder name
-# 4. Commit and push in Obsidian/Notes project
-# 5. Commit and push in related code folder (if any)
-```
-
-### Automatic Execution
-
-When user says "end session" (or "end", "done", "finish session"):
-
-**Step 1: Summarize and Update Session Note**
-- Write summary of what was accomplished
-- List any blockers or open questions
-- Ensure session note has meaningful name (NOT "New Session" or project name)
-
-**Step 2: Update TODO.md**
-- Mark completed tasks with `[x]`
-- Keep in-progress tasks with `[ ]`
-- Add any newly discovered tasks
-
-**Step 3: Commit and Push Obsidian Project**
-```bash
-cd [OBSIDIAN_PROJECT_DIR]
-git add .
-git status  # Check what's being committed
-git commit -m "docs: Session NNNN complete - [brief description]"
-git push
-```
-
-**Step 4: Commit and Push Code Repository (if applicable)**
-```bash
-cd [CODE_PROJECT_DIR]
-git add .
-git status
-git commit -m "feat/fix/refactor: [description of changes]"
-git push
-```
-
-**Step 5: Confirm Completion**
-Report back:
-- Session note filename (should be descriptive)
-- Commits made (both repos if applicable)
-- Any uncommitted changes that were skipped
-- Next session starting point
-
-### Project-Code Directory Mapping
-
-Add your project mappings to `~/.config/pai/project-mappings.json`:
-
-```json
-{
-  "mappings": [
-    { "obsidian": "My Project", "code_dir": "~/path/to/code" }
-  ]
-}
-```
-
-PAI reads this file during `end session` to know which code repositories to commit alongside their Obsidian project notes. Run `pai setup` to configure your mappings interactively.
-
-For personal preferences (notification channels, voice settings, agent defaults), see `~/.config/pai/agent-prefs.md`.
-
-### Important Rules
-
-- **NEVER skip the code repo commit** if code changes were made
-- **ALWAYS rename placeholder session notes** before committing
-- **ALWAYS use clean commit messages** (no AI signatures)
-- **CHECK for uncommitted changes** in both locations
-- **REPORT what was pushed** so user knows the state
+**Key commands:** "pause session", "end session", "go"/"continue", "cpp" (commit-push-publish).
 
 ---
 
@@ -722,7 +653,7 @@ For personal preferences (notification channels, voice settings, agent defaults)
 4. **Always spotcheck** - verification is mandatory
 5. **Never search home** - use specific subdirectories
 6. **Autonomous swarm mode** - spawn orchestrator, let agents do the work, no questions
-7. **End session = full cleanup** - notes, TODO, commit, push everywhere
+7. **Session lifecycle in CORE skill** - pause, end, continue, cpp commands
 8. **Plan mode for 3+ steps** - write specs, evaluate approaches, execute with verification
 9. **Verify before done** - prove it works, don't just claim it
 10. **Learn from corrections** - update tasks/lessons.md after every user correction
@@ -730,4 +661,6 @@ For personal preferences (notification channels, voice settings, agent defaults)
 12. **Fix bugs autonomously** - investigate, resolve, verify without hand-holding
 13. **Task management** - plan to tasks/todo.md first, track progress, document results
 
+**CLAUDE.md + CORE skill = complete PAI configuration.** CLAUDE.md covers agent architecture and engineering standards. CORE skill covers identity, session lifecycle, notifications, and compaction resilience.
+
 This is constitutional. Violations waste time, money, and context.