ei-tui 0.1.12 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/core/processor.ts

@@ -131,6 +131,8 @@ export class Processor {
   private lastClaudeCodeSync = 0;
   private claudeCodeImportInProgress = false;
   private pendingConflict: StateConflictData | null = null;
+  private storage: Storage | null = null;
+  private importAbortController = new AbortController();
 
   constructor(ei: Ei_Interface) {
     this.interface = ei;
@@ -150,6 +152,7 @@ export class Processor {
 
   async start(storage: Storage): Promise<void> {
     console.log(`[Processor ${this.instanceId}] start() called`);
+    this.storage = storage;
     await this.stateManager.initialize(storage);
     if (this.stopped) {
       console.log(`[Processor ${this.instanceId}] stopped during init, not starting loop`);
@@ -258,6 +261,7 @@ export class Processor {
     }
 
     this.running = false;
+    this.importAbortController.abort();
     this.queueProcessor.abort();
     await this.stateManager.flush();
     console.log(`[Processor ${this.instanceId}] stopped`);
@@ -268,6 +272,7 @@ export class Processor {
     this.interface.onSaveAndExitStart?.();
 
     this.queueProcessor.abort();
+    this.importAbortController.abort();
     if (this.openCodeImportInProgress) {
       console.log(`[Processor ${this.instanceId}] Aborting OpenCode import in progress`);
       this.openCodeImportInProgress = false;
@@ -332,6 +337,7 @@ export class Processor {
     }
 
     this.pendingConflict = null;
+    this.importAbortController = new AbortController();
     this.running = true;
     this.runLoop();
     this.interface.onStateImported?.();
@@ -391,6 +397,9 @@ export class Processor {
       await this.checkAndSyncOpenCode(human, now);
     }
 
+    if (this.isTUI && human.settings?.backup?.enabled) {
+      await this.checkAndRunRollingBackup(human, now);
+    }
     if (this.isTUI && human.settings?.claudeCode?.integration && this.stateManager.queue_length() === 0) {
       await this.checkAndSyncClaudeCode(human, now);
     }
@@ -436,6 +445,33 @@ export class Processor {
     }
   }
 
+  private async checkAndRunRollingBackup(human: HumanEntity, now: number): Promise<void> {
+    if (!this.storage) return;
+    const cfg = human.settings!.backup!;
+    const intervalMs = cfg.interval_ms ?? 3_600_000;  // default: 1 hour
+    const maxBackups = cfg.max_backups ?? 24;
+    const lastBackup = cfg.last_backup ? new Date(cfg.last_backup).getTime() : 0;
+
+    if (now - lastBackup < intervalMs) return;
+
+    // Update timestamp BEFORE async work to prevent duplicate triggers
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        backup: { ...cfg, last_backup: new Date(now).toISOString() },
+      },
+    });
+
+    const state = this.stateManager.getStorageState();
+    try {
+      await this.storage.saveRollingBackup(state, maxBackups);
+      console.log(`[Processor] Rolling backup saved (max=${maxBackups})`);
+    } catch (err) {
+      console.warn(`[Processor] Rolling backup failed:`, err);
+    }
+  }
+
   private async checkAndSyncOpenCode(human: HumanEntity, now: number): Promise<void> {
     if (this.openCodeImportInProgress) {
       return;
@@ -471,6 +507,7 @@ export class Processor {
         importOpenCodeSessions({
           stateManager: this.stateManager,
           interface: this.interface,
+          signal: this.importAbortController.signal,
         })
       )
       .then((result) => {
@@ -525,6 +562,7 @@ export class Processor {
         importClaudeCodeSessions({
           stateManager: this.stateManager,
           interface: this.interface,
+          signal: this.importAbortController.signal,
         })
       )
       .then((result) => {

package/src/core/types.ts

@@ -192,6 +192,13 @@ export interface CeremonyConfig {
   dedup_threshold?: number;  // Cosine similarity threshold for dedup candidates. Default: 0.85
 }
 
+export interface BackupConfig {
+  enabled?: boolean;       // Default: false (opt-in)
+  max_backups?: number;    // Default: 24
+  interval_ms?: number;   // Default: 3600000 (1 hour)
+  last_backup?: string;   // ISO timestamp of last backup run
+}
+
 export interface HumanSettings {
   default_model?: string;
   oneshot_model?: string;           // Model for AI-assist (wand) requests; falls back to default_model
@@ -203,6 +210,7 @@ export interface HumanSettings {
   sync?: SyncCredentials;
   opencode?: OpenCodeSettings;
   ceremony?: CeremonyConfig;
+  backup?: BackupConfig;
   claudeCode?: import("../integrations/claude-code/types.js").ClaudeCodeSettings;
 }
 

package/src/integrations/claude-code/importer.ts

@@ -29,6 +29,7 @@ export interface ClaudeCodeImporterOptions {
   stateManager: StateManager;
   interface?: Ei_Interface;
   reader?: IClaudeCodeReader;
+  signal?: AbortSignal;
 }
 
 // =============================================================================
@@ -183,7 +184,7 @@ function updateProcessedState(
 export async function importClaudeCodeSessions(
   options: ClaudeCodeImporterOptions
 ): Promise<ClaudeCodeImportResult> {
-  const { stateManager, interface: eiInterface } = options;
+  const { stateManager, interface: eiInterface, signal } = options;
   const reader = options.reader ?? new ClaudeCodeReader();
 
   const result: ClaudeCodeImportResult = {
@@ -204,6 +205,7 @@ export async function importClaudeCodeSessions(
     else if (topicResult === "updated") result.topicsUpdated++;
   }
 
+  if (signal?.aborted) return result;
   if (result.topicsCreated > 0 || result.topicsUpdated > 0) {
     eiInterface?.onHumanUpdated?.();
   }
@@ -240,6 +242,8 @@ export async function importClaudeCodeSessions(
     return result;
   }
 
+  if (signal?.aborted) return result;
+
   console.log(
     `[ClaudeCode] Processing session: "${targetSession.title}" ` +
       `(last message: ${targetSession.lastMessageAt})`
@@ -253,6 +257,8 @@ export async function importClaudeCodeSessions(
     return result;
   }
 
+  if (signal?.aborted) return result;
+
   // ─── Step 4: Ensure persona, archive, clear, write messages ──────────
   const persona = ensureClaudeCodePersona(stateManager, eiInterface);
   result.personaCreated = !stateManager.persona_getByName(CLAUDE_CODE_PERSONA_NAME);
@@ -286,7 +292,7 @@ export async function importClaudeCodeSessions(
   eiInterface?.onMessageAdded?.(persona.id);
 
   // ─── Step 5: Queue extraction for new messages ────────────────────────
-  if (toAnalyze.length > 0) {
+  if (toAnalyze.length > 0 && !signal?.aborted) {
     const allInState = stateManager.messages_get(persona.id);
     const analyzeIds = new Set(toAnalyze.map((m) => m.id));
     const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));

package/src/integrations/opencode/importer.ts

@@ -32,6 +32,7 @@ export interface OpenCodeImporterOptions {
   stateManager: StateManager;
   interface?: Ei_Interface;
   reader?: IOpenCodeReader;
+  signal?: AbortSignal;
 }
 
 // =============================================================================
@@ -94,7 +95,7 @@ function filterRelevantMessages(messages: OpenCodeMessage[]): OpenCodeMessage[]
 export async function importOpenCodeSessions(
   options: OpenCodeImporterOptions
 ): Promise<ImportResult> {
-  const { stateManager, interface: eiInterface } = options;
+  const { stateManager, interface: eiInterface, signal } = options;
   const reader = options.reader ?? await createOpenCodeReader();
 
   const result: ImportResult = {
@@ -110,6 +111,8 @@ export async function importOpenCodeSessions(
   // Always runs (cheap), so session titles stay current regardless of
   // whether we process messages this cycle.
   const allSessions = await reader.getSessionsUpdatedSince(new Date(0));
+
+  if (signal?.aborted) return result;
   const primarySessions = allSessions.filter(s => !s.parentId);
 
   for (const session of primarySessions) {
@@ -156,6 +159,7 @@ export async function importOpenCodeSessions(
     // Nothing new to process — bump last_sync and return
     console.log(`[OpenCode] All sessions processed, nothing new since extraction_point`);
     return result;
+  if (signal?.aborted) return result;
   }
 
   console.log(
@@ -171,6 +175,7 @@ export async function importOpenCodeSessions(
     // Empty session — mark processed and advance
     updateExtractionState(stateManager, targetSession);
     return result;
+  if (signal?.aborted) return result;
   }
 
   // ─── Step 4: Resolve agents → personas, group by persona ID ────────
@@ -241,8 +246,10 @@ export async function importOpenCodeSessions(
         messages_analyze: toAnalyze,
       };
 
-      queueAllScans(context, stateManager);
-      result.extractionScansQueued += 4;
+      if (!signal?.aborted) {
+        queueAllScans(context, stateManager);
+        result.extractionScansQueued += 4;
+      }
     }
   }
 

package/src/prompts/response/sections.ts

@@ -319,6 +319,20 @@ export function buildSystemKnowledgeSection(isTUI: boolean): string {
 - Hover over a persona to see controls: pause, edit (Pencil), archive, delete (Trash)
 - Click a persona to switch conversations
 - The [+] button creates new personas`;
+  const externalImportNotes = isTUI ? `
+
+### Coding Agent Integrations
+Ei can silently read session histories from AI coding tools and build memories from them — so you learn who the human works with, what projects they care about, and what they've been building, without them having to relay it manually.
+
+Both integrations are enabled here in settings. Look for the \`opencode\` or \`claudeCode\` section and set \`integration: true\`.
+
+#### OpenCode
+When enabled, Ei reads OpenCode's session history and builds a persona for each AI agent the human works with (Sisyphus, Oracle, etc.). Each session becomes a topic on that persona, so Ei can discuss the work in context.
+
+The connection also runs the other direction: running \`ei --install\` in the terminal registers Ei as a tool inside both OpenCode and Claude Code at the same time. Once installed, those coding agents can query Ei's memory directly — facts, traits, topics, people, quotes — giving them persistent knowledge about the human across sessions.
+
+#### Claude Code
+When enabled, Ei reads Claude Code's session history (stored in \`~/.claude/projects/\`) and creates a single "Claude Code" persona representing those conversations. Sessions become topics, and Ei learns from the work without the human having to explain it.` : "";
 
   return `# System Knowledge
 
@@ -364,6 +378,7 @@ The human can view and edit all of this by ${seeHumanDataAction}.
 - Configure LLM providers (local or cloud)
 - Set up device sync (encrypted backup to restore on other devices)
 - Adjust ceremony timing (overnight persona evolution)
+${externalImportNotes}
 
 ### Tips You Can Share
 - If they want to talk to a persona privately, tell them about the "Groups" functionality

package/src/storage/interface.ts

@@ -6,4 +6,6 @@ export interface Storage {
   load(): Promise<StorageState | null>;
   moveToBackup(): Promise<void>;
   loadBackup(): Promise<StorageState | null>;
+  /** Save a rolling backup of state with a local timestamp filename. Prunes oldest if over limit. */
+  saveRollingBackup(state: StorageState, maxBackups: number): Promise<void>;
 }

package/src/storage/local.ts

@@ -81,4 +81,9 @@ export class LocalStorage implements Storage {
       (e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED")
     );
   }
+  /** No-op in browser — rolling backups are TUI-only (filesystem required). */
+  async saveRollingBackup(_state: StorageState, _maxBackups: number): Promise<void> {
+    // Intentional no-op: localStorage has no directory/file concept.
+    // The Processor gates this call with `this.isTUI` so it never runs in the browser.
+  }
 }

package/tui/src/index.tsx

@@ -1,5 +1,25 @@
 import { render } from "@opentui/solid";
 import { App } from "./app";
+import { InstanceLock } from "./util/instance-lock";
+import { FileStorage } from "./storage/file";
+
+const storage = new FileStorage(Bun.env.EI_DATA_PATH);
+const lock = new InstanceLock(storage.getDataPath());
+const lockResult = await lock.acquire();
+
+if (!lockResult.acquired) {
+  process.stderr.write(
+    `\nEi cannot start: another instance is already running.\n` +
+    `  PID:     ${lockResult.pid}\n` +
+    `  Started: ${lockResult.started}\n` +
+    `  Lock:    ${storage.getDataPath()}/ei.lock\n\n` +
+    `Close the other instance first, or delete the lock file if it is stale.\n\n`
+  );
+  process.exit(1);
+}
+
+// Release lock when the app exits (keyboard context calls process.exit(0) on normal quit)
+process.on("exit", () => { void lock.release(); });
 
 render(App, {
   exitOnCtrlC: false,

package/tui/src/storage/file.ts

@@ -1,15 +1,16 @@
 import type { StorageState } from "../../../src/core/types";
 import type { Storage } from "../../../src/storage/interface";
 import { join } from "path";
-import { mkdir, rename, unlink } from "fs/promises";
+import { mkdir, rename, unlink, readdir } from "fs/promises";
 
 const STATE_FILE = "state.json";
 const BACKUP_FILE = "state.backup.json";
+const BACKUPS_DIR = "backups";
 const LOCK_TIMEOUT_MS = 5000;
 const LOCK_RETRY_DELAY_MS = 50;
 
 export class FileStorage implements Storage {
-  private dataPath: string;
+  private readonly dataPath: string;
 
   constructor(dataPath?: string) {
     if (dataPath) {
@@ -22,6 +23,10 @@ export class FileStorage implements Storage {
     }
   }
 
+  getDataPath(): string {
+    return this.dataPath;
+  }
+
   async isAvailable(): Promise<boolean> {
     try {
       await this.ensureDataDir();
@@ -101,6 +106,38 @@ export class FileStorage implements Storage {
 
     return null;
   }
+  async saveRollingBackup(state: StorageState, maxBackups: number): Promise<void> {
+    const backupsPath = join(this.dataPath, BACKUPS_DIR);
+    await mkdir(backupsPath, { recursive: true });
+
+    // Filename is local timestamp: YYYY-MM-DDTHH-MM-SS (colons replaced for FS compat)
+    const now = new Date();
+    const pad = (n: number) => String(n).padStart(2, "0");
+    const name = [
+      now.getFullYear(),
+      "-", pad(now.getMonth() + 1),
+      "-", pad(now.getDate()),
+      "T", pad(now.getHours()),
+      "-", pad(now.getMinutes()),
+      "-", pad(now.getSeconds()),
+    ].join("") + ".json";
+
+    const destPath = join(backupsPath, name);
+    await this.atomicWrite(destPath, JSON.stringify(state, null, 2));
+
+    // Prune: keep only the newest maxBackups files
+    const entries = await readdir(backupsPath);
+    const jsonFiles = entries
+      .filter(f => f.endsWith(".json"))
+      .sort();  // ISO-like names sort chronologically
+
+    const excess = jsonFiles.length - maxBackups;
+    if (excess > 0) {
+      for (const old of jsonFiles.slice(0, excess)) {
+        await unlink(join(backupsPath, old));
+      }
+    }
+  }
 
   private async ensureDataDir(): Promise<void> {
     try {

package/tui/src/util/instance-lock.ts

@@ -0,0 +1,92 @@
+import { join } from "path";
+import { unlink } from "fs/promises";
+
+const LOCK_FILE = "ei.lock";
+
+export interface LockData {
+  pid: number;
+  started: string;
+  frontend: string;
+}
+
+export type AcquireResult =
+  | { acquired: true }
+  | { acquired: false; reason: "live_process"; pid: number; started: string };
+
+export class InstanceLock {
+  private lockPath: string;
+  private held = false;
+
+  constructor(dataPath: string) {
+    this.lockPath = join(dataPath, LOCK_FILE);
+  }
+
+  /**
+   * Try to acquire the instance lock.
+   *
+   * - No lock file → write and proceed.
+   * - Lock file exists, PID is dead → steal and proceed.
+   * - Lock file exists, PID is live → return { acquired: false }.
+   */
+  async acquire(): Promise<AcquireResult> {
+    const existing = await this.readLock();
+
+    if (existing) {
+      const alive = isProcessAlive(existing.pid);
+      if (alive) {
+        return { acquired: false, reason: "live_process", pid: existing.pid, started: existing.started };
+      }
+      // Stale lock — fall through and overwrite
+    }
+
+    await this.writeLock();
+    this.held = true;
+    return { acquired: true };
+  }
+
+  /**
+   * Release the lock. Safe to call multiple times / if never acquired.
+   */
+  async release(): Promise<void> {
+    if (!this.held) return;
+    this.held = false;
+    try {
+      await unlink(this.lockPath);
+    } catch {
+      // Already gone — that's fine
+    }
+  }
+
+  private async readLock(): Promise<LockData | null> {
+    try {
+      const file = Bun.file(this.lockPath);
+      if (!(await file.exists())) return null;
+      const text = await file.text();
+      return JSON.parse(text) as LockData;
+    } catch {
+      return null;
+    }
+  }
+
+  private async writeLock(): Promise<void> {
+    const data: LockData = {
+      pid: process.pid,
+      started: new Date().toISOString(),
+      frontend: "tui",
+    };
+    await Bun.write(this.lockPath, JSON.stringify(data, null, 2));
+  }
+}
+
+/**
+ * Check whether a process with the given PID is currently running.
+ * Uses kill(pid, 0) — sends no signal, just checks existence.
+ */
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/tui/src/util/logger.ts

@@ -46,9 +46,7 @@ function formatMessage(level: LogLevel, message: string, data?: unknown): string
 
 function writeLogSync(level: LogLevel, message: string, data?: unknown): void {
   if (!shouldLog(level)) return;
-  
   const line = formatMessage(level, message, data);
-  
   try {
     appendFileSync(getLogPath(), line);
   } catch {}

package/tui/src/util/yaml-serializers.ts

@@ -5,6 +5,7 @@ import type {
   HumanSettings,
   CeremonyConfig,
   OpenCodeSettings,
+  BackupConfig,
   Fact,
   Trait,
   Topic,
@@ -455,6 +456,11 @@ interface EditableSettingsData {
     integration?: boolean | null;
     polling_interval_ms?: number | null;
   };
+  backup?: {
+    enabled?: boolean | null;
+    max_backups?: number | null;
+    interval_ms?: number | null;
+  };
 }
 
 export function settingsToYAML(settings: HumanSettings | undefined): string {
@@ -477,6 +483,11 @@ export function settingsToYAML(settings: HumanSettings | undefined): string {
       integration: settings?.claudeCode?.integration ?? false,
       polling_interval_ms: settings?.claudeCode?.polling_interval_ms ?? 1800000,
     },
+    backup: {
+      enabled: settings?.backup?.enabled ?? false,
+      max_backups: settings?.backup?.max_backups ?? 24,
+      interval_ms: settings?.backup?.interval_ms ?? 3600000,
+    },
   };
   
   return YAML.stringify(data, {
@@ -521,6 +532,16 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
       processed_sessions: original?.claudeCode?.processed_sessions,
     };
   }
+
+  let backup: BackupConfig | undefined;
+  if (data.backup) {
+    backup = {
+      enabled: nullToUndefined(data.backup.enabled),
+      max_backups: nullToUndefined(data.backup.max_backups),
+      interval_ms: nullToUndefined(data.backup.interval_ms),
+      last_backup: original?.backup?.last_backup,
+    };
+  }
   
   return {
     ...original,
@@ -530,6 +551,7 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
     ceremony,
     opencode,
     claudeCode,
+    backup,
   };
 }