clementine-agent 1.1.14 → 1.1.16

package/dist/agent/agent-manager.d.ts

@@ -38,10 +38,9 @@ export interface AgentCreateConfig {
 }
 export declare class AgentManager {
     private agentsDir;
-    private legacyManager;
     private cache;
     private cacheTime;
-    constructor(agentsDir: string, legacyProfilesDir: string);
+    constructor(agentsDir: string);
     private refreshIfStale;
     private loadAgentFile;
     get(slug: string): AgentProfile | null;

package/dist/agent/agent-manager.js

@@ -15,7 +15,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import matter from 'gray-matter';
 import { randomBytes } from 'node:crypto';
-import { ProfileManager } from './profiles.js';
+// Phase 14 cleanup: legacy ProfileManager (vault/00-System/profiles/*.md)
+// removed — that directory has been empty for a long time and the new format
+// (vault/00-System/agents/<slug>/agent.md) supersedes it. Constructor no
+// longer takes a legacyProfilesDir argument.
 import { getScaffoldForRole } from './role-scaffolds.js';
 import { writeGoalForOwner } from '../tools/shared.js';
 // ── Keychain helpers for agent secrets ────────────────────────────────
@@ -39,12 +42,10 @@ function deleteAgentSecret(slug, key) {
 const CACHE_TTL_MS = 60_000;
 export class AgentManager {
     agentsDir;
-    legacyManager;
     cache = new Map();
     cacheTime = 0;
-    constructor(agentsDir, legacyProfilesDir) {
+    constructor(agentsDir) {
         this.agentsDir = agentsDir;
-        this.legacyManager = new ProfileManager(legacyProfilesDir);
     }
     refreshIfStale() {
         const now = Date.now();
@@ -76,12 +77,6 @@ export class AgentManager {
                 // agents dir not readable
             }
         }
-        // 2. Load legacy profiles (only for slugs not already loaded)
-        for (const legacy of this.legacyManager.listAll()) {
-            if (!profiles.has(legacy.slug)) {
-                profiles.set(legacy.slug, legacy);
-            }
-        }
         this.cache = profiles;
         this.cacheTime = now;
     }

package/dist/agent/assistant.js

@@ -13,7 +13,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { query as rawQuery, listSubagents, getSubagentMessages, SYSTEM_PROMPT_DYNAMIC_BOUNDARY, } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, PROFILES_DIR, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, TASK_BUDGET_TOKENS, ENABLE_1M_CONTEXT, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, } from '../config.js';
+import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, TASK_BUDGET_TOKENS, ENABLE_1M_CONTEXT, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, } from '../config.js';
 import { DEFAULT_CHANNEL_CAPABILITIES } from '../types.js';
 import { enforceToolPermissions, getSecurityPrompt, getHeartbeatSecurityPrompt, getCronSecurityPrompt, getHeartbeatDisallowedTools, logToolUse, setProfileTier, setProfileAllowedTools, setAgentDir, setSendPolicy, setInteractionSource, logAuditJsonl, } from './hooks.js';
 import { scanner } from '../security/scanner.js';
@@ -746,7 +746,7 @@ export class PersonalAssistant {
     /** Hot correction buffer — explicit behavioral corrections applied before nightly SI. */
     hotCorrections = [];
     constructor() {
-        this.profileManager = new AgentManager(AGENTS_DIR, PROFILES_DIR);
+        this.profileManager = new AgentManager(AGENTS_DIR);
         this.promptCache = new PromptCache();
         this.initPromptWatchers();
         this.loadSessions();

package/dist/cli/chat.js

@@ -74,9 +74,9 @@ export async function cmdChat(opts) {
     }
     // Apply initial profile override
     if (opts.profile) {
-        const { PROFILES_DIR, AGENTS_DIR } = await import('../config.js');
+        const { AGENTS_DIR } = await import('../config.js');
         const { AgentManager } = await import('../agent/agent-manager.js');
-        const pm = new AgentManager(AGENTS_DIR, PROFILES_DIR);
+        const pm = new AgentManager(AGENTS_DIR);
         const profile = pm.get(opts.profile);
         if (profile) {
             gateway.setSessionProfile(sessionKey, opts.profile);

package/dist/cli/dashboard.js

@@ -1633,8 +1633,7 @@ export async function cmdDashboard(opts) {
             }
             result.projects = { projects: cachedProjects ?? [] };
             try {
-                const profilesDir = path.join(VAULT_DIR, '00-System', 'profiles');
-                const mgr = new AgentManager(AGENTS_DIR, profilesDir);
+                const mgr = new AgentManager(AGENTS_DIR);
                 const allAgents = mgr.listAll();
                 let botStatuses = {};
                 try {
@@ -1964,8 +1963,7 @@ export async function cmdDashboard(opts) {
             //
             try {
                 const agDir = AGENTS_DIR;
-                const profilesDir = path.join(VAULT_DIR, '00-System', 'profiles');
-                const mgr = new AgentManager(agDir, profilesDir);
+                const mgr = new AgentManager(agDir);
                 const allAgents = mgr.listAll();
                 // Bot statuses from disk
                 let botStatuses = {};
@@ -4278,12 +4276,10 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
     });
     // ── Profile routes ─────────────────────────────────────────────────
     app.get('/api/profiles', gwHandler(async (gw, _req, res) => {
-        const profilesDir = path.join(VAULT_DIR, '00-System', 'profiles');
-        if (!existsSync(profilesDir)) {
-            res.json({ profiles: [], active: null });
-            return;
-        }
-        const pm = new AgentManager(AGENTS_DIR, profilesDir);
+        // Phase 14: previously checked the legacy profilesDir; now that the
+        // legacy fallback is gone, AgentManager.listAll() returns [] when
+        // AGENTS_DIR is missing or empty. No separate guard needed.
+        const pm = new AgentManager(AGENTS_DIR);
         const profiles = pm.listAll().map(p => ({
             slug: p.slug,
             name: p.name,
@@ -5343,8 +5339,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
     // ── Team API endpoints ──────────────────────────────────────────────
     app.get('/api/team/agents', async (_req, res) => {
         try {
-            const profilesDir = path.join(VAULT_DIR, '00-System', 'profiles');
-            const mgr = new AgentManager(AGENTS_DIR, profilesDir);
+            const mgr = new AgentManager(AGENTS_DIR);
             const agents = mgr.listAll();
             res.json(agents.map(a => ({
                 slug: a.slug,
@@ -5440,8 +5435,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
     app.get('/api/office', async (_req, res) => {
         try {
             const data = await cachedAsync('office', 10_000, async () => {
-                const profilesDir = path.join(VAULT_DIR, '00-System', 'profiles');
-                const mgr = new AgentManager(AGENTS_DIR, profilesDir);
+                const mgr = new AgentManager(AGENTS_DIR);
                 const allAgents = mgr.listAll();
                 // ── Bot statuses ──
                 let botStatuses = {};

package/dist/config/effective-config.js

@@ -59,11 +59,9 @@ const SPECS = [
 // ── Keychain-ref resolution ──────────────────────────────────────────
 // Mirrors config.ts's lazy/cached resolver but kept independent so this
 // module stays a pure utility (no shared mutable state with the daemon).
+import { parseEnvText, shellEscape } from './env-parser.js';
 const KEYCHAIN_REF_PREFIX = 'keychain:'; // pragma: allowlist secret
 const refCache = new Map();
-function shellEscape(s) {
-    return `'${s.replace(/'/g, "'\\''")}'`;
-}
 /** Hard cap per shell call — see config.ts for rationale. */
 const KEYCHAIN_TIMEOUT_MS = Math.max(500, parseInt(process.env.CLEMENTINE_KEYCHAIN_TIMEOUT_MS ?? '3000', 10) || 3000);
 function resolveRef(stub) {
@@ -86,23 +84,7 @@ function readEnvFile(baseDir) {
     const envPath = path.join(baseDir, '.env');
     if (!existsSync(envPath))
         return {};
-    const result = {};
-    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        const key = trimmed.slice(0, eqIndex);
-        let value = trimmed.slice(eqIndex + 1);
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        result[key] = value;
-    }
-    return result;
+    return parseEnvText(readFileSync(envPath, 'utf-8'));
 }
 function getJsonValue(json, dottedPath) {
     const parts = dottedPath.split('.');

package/dist/config/env-parser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared parser for `.env`-style files.
+ *
+ * Phase 14 cleanup: this logic was previously duplicated in 4+ places
+ * (src/config.ts, src/tools/shared.ts, src/config/effective-config.ts,
+ * src/vault-migrations/0005-create-clementine-json.ts). All implementations
+ * were identical line-for-line; consolidating here avoids future drift.
+ *
+ * Each caller still wraps this with its own file-read since the path
+ * varies (BASE_DIR-relative vs explicit baseDir param vs lazy/cached).
+ *
+ * Format:
+ *   KEY=value             — bare value
+ *   KEY="value"           — double-quoted; quotes stripped
+ *   KEY='value'           — single-quoted; quotes stripped
+ *   # comment             — ignored
+ *   <blank line>          — ignored
+ *   malformed lines       — silently skipped (no `=` separator)
+ */
+export declare function parseEnvText(text: string): Record<string, string>;
+/**
+ * POSIX shell single-quote escape. Used by every keychain shell-out site.
+ * Phase 14 cleanup: was duplicated in src/config.ts and
+ * src/config/effective-config.ts.
+ */
+export declare function shellEscape(s: string): string;
+//# sourceMappingURL=env-parser.d.ts.map

package/dist/config/env-parser.js

@@ -0,0 +1,47 @@
+/**
+ * Shared parser for `.env`-style files.
+ *
+ * Phase 14 cleanup: this logic was previously duplicated in 4+ places
+ * (src/config.ts, src/tools/shared.ts, src/config/effective-config.ts,
+ * src/vault-migrations/0005-create-clementine-json.ts). All implementations
+ * were identical line-for-line; consolidating here avoids future drift.
+ *
+ * Each caller still wraps this with its own file-read since the path
+ * varies (BASE_DIR-relative vs explicit baseDir param vs lazy/cached).
+ *
+ * Format:
+ *   KEY=value             — bare value
+ *   KEY="value"           — double-quoted; quotes stripped
+ *   KEY='value'           — single-quoted; quotes stripped
+ *   # comment             — ignored
+ *   <blank line>          — ignored
+ *   malformed lines       — silently skipped (no `=` separator)
+ */
+export function parseEnvText(text) {
+    const result = {};
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex);
+        let value = trimmed.slice(eqIndex + 1);
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * POSIX shell single-quote escape. Used by every keychain shell-out site.
+ * Phase 14 cleanup: was duplicated in src/config.ts and
+ * src/config/effective-config.ts.
+ */
+export function shellEscape(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+//# sourceMappingURL=env-parser.js.map

package/dist/config.d.ts

@@ -10,6 +10,7 @@ import type { Models } from './types.js';
 export declare const PKG_DIR: string;
 /** Data home — user data, vault, .env, logs, sessions. */
 export declare const BASE_DIR: string;
+import { shellEscape as _shellEscape } from './config/env-parser.js';
 /** Merged view of process.env overlaid with .env. Use for classifyIntegrations / summarizeIntegrationStatus. */
 export declare function envSnapshot(): Record<string, string | undefined>;
 /** Test-only: clear the keychain ref cache so re-resolution can be tested. */
@@ -30,7 +31,6 @@ export declare const TOPICS_DIR: string;
 export declare const TASKS_DIR: string;
 export declare const TEMPLATES_DIR: string;
 export declare const INBOX_DIR: string;
-export declare const PROFILES_DIR: string;
 export declare const AGENTS_DIR: string;
 export declare const SOUL_FILE: string;
 export declare const AGENTS_FILE: string;
@@ -47,7 +47,7 @@ export declare const IDENTITY_FILE: string;
 export declare const ASSISTANT_NAME: string;
 export declare const ASSISTANT_NICKNAME: string;
 export declare const OWNER_NAME: string;
-export declare function shellEscape(s: string): string;
+export declare const shellEscape: typeof _shellEscape;
 export declare const MODELS: Models;
 export declare const BUDGET: {
     heartbeat: number;

package/dist/config.js

@@ -19,28 +19,12 @@ export const PKG_DIR = path.resolve(__dirname, '..');
 /** Data home — user data, vault, .env, logs, sessions. */
 export const BASE_DIR = process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine');
 // ── .env parser (never sets process.env) ────────────────────────────
+import { parseEnvText, shellEscape as _shellEscape } from './config/env-parser.js';
 function readEnvFile() {
     const envPath = path.join(BASE_DIR, '.env');
     if (!existsSync(envPath))
         return {};
-    const result = {};
-    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        const key = trimmed.slice(0, eqIndex);
-        let value = trimmed.slice(eqIndex + 1);
-        // Strip surrounding quotes
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        result[key] = value;
-    }
-    return result;
+    return parseEnvText(readFileSync(envPath, 'utf-8'));
 }
 const env = readEnvFile();
 // ── Keychain-ref resolution (lazy, cached) ──────────────────────────
@@ -141,7 +125,9 @@ export const TOPICS_DIR = path.join(VAULT_DIR, '04-Topics');
 export const TASKS_DIR = path.join(VAULT_DIR, '05-Tasks');
 export const TEMPLATES_DIR = path.join(VAULT_DIR, '06-Templates');
 export const INBOX_DIR = path.join(VAULT_DIR, '07-Inbox');
-export const PROFILES_DIR = path.join(SYSTEM_DIR, 'profiles');
+// PROFILES_DIR (vault/00-System/profiles/) removed in Phase 14 cleanup —
+// the legacy profile format hasn't been used in production for a long time.
+// AGENTS_DIR is the canonical home for agent definitions.
 export const AGENTS_DIR = path.join(SYSTEM_DIR, 'agents');
 export const SOUL_FILE = path.join(SYSTEM_DIR, 'SOUL.md');
 export const AGENTS_FILE = path.join(SYSTEM_DIR, 'AGENTS.md');
@@ -171,9 +157,9 @@ export const ASSISTANT_NAME = getEnvOrJson('ASSISTANT_NAME', json.assistantName,
 export const ASSISTANT_NICKNAME = getEnv('ASSISTANT_NICKNAME', 'Clemmy');
 export const OWNER_NAME = getEnvOrJson('OWNER_NAME', json.ownerName, '');
 // ── Secrets (with macOS Keychain fallback) ───────────────────────────
-export function shellEscape(s) {
-    return `'${s.replace(/'/g, "'\\''")}'`;
-}
+// Re-export shellEscape from the shared helper so existing call sites
+// (config.ts internal uses + downstream importers) keep working.
+export const shellEscape = _shellEscape;
 function getSecret(envKey, keychainService) {
     // Resolve keychain refs from .env in place so secrets stored as stubs
     // come back as their real values (same blind spot as getEnv had pre-fix).

package/dist/gateway/router.js

@@ -10,7 +10,7 @@ import pino from 'pino';
 import { PersonalAssistant } from '../agent/assistant.js';
 import { runWithTrace, logAuditJsonl } from '../agent/hooks.js';
 import { SelfImproveLoop } from '../agent/self-improve.js';
-import { MODELS, PROFILES_DIR, AGENTS_DIR, TEAM_COMMS_LOG, BASE_DIR, SEEN_CHANNELS_FILE } from '../config.js';
+import { MODELS, AGENTS_DIR, TEAM_COMMS_LOG, BASE_DIR, SEEN_CHANNELS_FILE } from '../config.js';
 import { scanner } from '../security/scanner.js';
 import { lanes } from './lanes.js';
 import { AgentManager } from '../agent/agent-manager.js';
@@ -338,7 +338,7 @@ export class Gateway {
     // ── Team system accessors ──────────────────────────────────────────
     getAgentManager() {
         if (!this._agentManager) {
-            this._agentManager = new AgentManager(AGENTS_DIR, PROFILES_DIR);
+            this._agentManager = new AgentManager(AGENTS_DIR);
         }
         return this._agentManager;
     }

package/dist/index.js

@@ -328,7 +328,6 @@ function ensureVaultDirs() {
         config.TASKS_DIR,
         config.TEMPLATES_DIR,
         config.INBOX_DIR,
-        config.PROFILES_DIR,
     ];
     for (const dir of dirs) {
         if (!existsSync(dir)) {

package/dist/memory/graph-store.d.ts

@@ -16,6 +16,14 @@
  * returns false and all graph features are silently skipped.
  */
 import type { EntityNode, EntityRef, GraphSyncStats, PathResult, RelationshipTriplet, TraversalResult } from '../types.js';
+/**
+ * Phase 13 — extract structured info from arbitrary error objects so log
+ * entries always carry SOMETHING useful even when err.message is empty.
+ * Node socket errors have .code, .errno, .syscall, .address, .port that
+ * tell us "ECONNREFUSED on /tmp/x.sock" instead of the empty string the
+ * falkordb client surfaces by default.
+ */
+export declare function extractErrorInfo(err: unknown): Record<string, unknown>;
 export declare class GraphStore {
     private db;
     private client;
@@ -23,6 +31,9 @@ export declare class GraphStore {
     private available;
     private persistenceDir;
     private ownsServer;
+    private livenessProbeTimer;
+    private livenessFailureStreak;
+    private livenessRestartAttempts;
     constructor(persistenceDir: string);
     /** Get the socket file path for this instance's data dir. */
     private get socketFilePath();
@@ -37,6 +48,19 @@ export declare class GraphStore {
      */
     connectToRunning(): Promise<boolean>;
     isAvailable(): boolean;
+    /**
+     * Periodic health check on the owned embedded server. Runs every 60s.
+     * Pings with a trivial Cypher query (RETURN 1). Two consecutive failures
+     * trigger a restart attempt. Backs off after 3 restart attempts to avoid
+     * crash-loop noise — at that point graph features stay disabled until
+     * the daemon is manually restarted.
+     *
+     * Daemon-only because client processes have their own reconnect loop on
+     * the .on('error') path. The probe specifically catches the case where
+     * the server hangs (no error event but stops responding).
+     */
+    private startLivenessProbe;
+    private attemptServerRestart;
     close(): Promise<void>;
     upsertEntity(label: string, id: string, props: Record<string, any>): Promise<void>;
     getEntity(label: string, id: string): Promise<EntityNode | null>;

package/dist/memory/graph-store.js

@@ -22,6 +22,46 @@ import pino from 'pino';
 const logger = pino({ name: 'clementine.graph' });
 const GRAPH_NAME = 'clementine';
 const WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+/**
+ * Phase 13 — extract structured info from arbitrary error objects so log
+ * entries always carry SOMETHING useful even when err.message is empty.
+ * Node socket errors have .code, .errno, .syscall, .address, .port that
+ * tell us "ECONNREFUSED on /tmp/x.sock" instead of the empty string the
+ * falkordb client surfaces by default.
+ */
+export function extractErrorInfo(err) {
+    if (!err)
+        return { errKind: 'no-error-object' };
+    if (typeof err !== 'object')
+        return { errKind: 'primitive', err: String(err).slice(0, 200) };
+    const e = err;
+    const out = {};
+    if (typeof e.message === 'string' && e.message.length > 0)
+        out.errMessage = e.message.slice(0, 200);
+    if (typeof e.name === 'string')
+        out.errName = e.name;
+    if (e.code !== undefined)
+        out.errCode = e.code;
+    if (e.errno !== undefined)
+        out.errno = e.errno;
+    if (e.syscall !== undefined)
+        out.errSyscall = e.syscall;
+    if (e.address !== undefined)
+        out.errAddress = e.address;
+    if (e.port !== undefined)
+        out.errPort = e.port;
+    if (e.path !== undefined)
+        out.errPath = e.path;
+    // Fall back to the constructor name + JSON shape if nothing meaningful surfaced
+    if (Object.keys(out).length === 0) {
+        out.errKind = e.constructor?.name ?? 'unknown';
+        try {
+            out.errJson = JSON.stringify(e).slice(0, 300);
+        }
+        catch { /* ignore */ }
+    }
+    return out;
+}
 /** Well-known file where the daemon writes the socket path for other processes. */
 const SOCKET_FILE_NAME = '.graph.sock';
 export class GraphStore {
@@ -31,6 +71,9 @@ export class GraphStore {
     available = false;
     persistenceDir;
     ownsServer = false;
+    livenessProbeTimer = null;
+    livenessFailureStreak = 0;
+    livenessRestartAttempts = 0;
     constructor(persistenceDir) {
         this.persistenceDir = persistenceDir;
     }
@@ -53,15 +96,21 @@ export class GraphStore {
             this.graph = this.db.selectGraph(GRAPH_NAME);
             this.available = true;
             this.ownsServer = true;
-            // Catch connection-level errors: log once, disable gracefully
+            // Catch connection-level errors with full diagnosis (Phase 13).
             let serverErrorLogged = false;
             this.db.on?.('error', (err) => {
                 if (!serverErrorLogged) {
                     serverErrorLogged = true;
-                    logger.warn({ err: err.message }, 'FalkorDB server error — disabling graph features');
+                    logger.warn(extractErrorInfo(err), 'FalkorDB server error — disabling graph features');
                     this.available = false;
                 }
             });
+            // Phase 13 — server-side liveness probe with auto-restart.
+            // Periodically (60s) ping the embedded server with a tiny query.
+            // If the ping fails, the server has hung or quietly died. Auto-
+            // restart by reinitializing instead of leaving graph features
+            // silently broken until the next daemon restart.
+            this.startLivenessProbe();
             // Write socket path so MCP/dashboard/assistant can connect
             writeFileSync(this.socketFilePath, this.db.socketPath, 'utf-8');
             // Create indexes for fast lookups
@@ -103,47 +152,62 @@ export class GraphStore {
             this.graph = this.client.selectGraph(GRAPH_NAME);
             this.available = true;
             this.ownsServer = false;
-            // Catch connection-level errors: disable and start reconnect loop
+            // Catch connection-level errors: disable and start reconnect loop.
+            // Phase 13: capture FULL error context (errno, code, syscall) instead
+            // of just .message — falkordb client emits raw socket errors that
+            // often have empty .message strings, leaving us blind to root cause.
             let errorHandled = false;
             this.client.on?.('error', (err) => {
                 if (errorHandled)
                     return;
                 errorHandled = true;
-                logger.warn({ err: err.message }, 'FalkorDB connection lost — starting reconnect loop');
+                const errInfo = extractErrorInfo(err);
+                logger.warn({ ...errInfo, pid: process.pid, socketPath }, 'FalkorDB connection lost — starting reconnect loop');
                 this.available = false;
                 try {
                     this.client?.disconnect?.();
                 }
                 catch { /* ignore */ }
-                // Reconnect loop: try every 30s up to 5 times, then back off to 5 min
+                // Reconnect schedule (Phase 13): exponential backoff from 1s up to
+                // 60s for the first 6 attempts (covers transient blips fast), then
+                // 5min × 5 (handles a daemon-restart window), then a slow 30min
+                // probe forever. Total time to "give up fast retries" reduced from
+                // 150s (5×30s) to 109s (1+3+10+30+60+5*60) but the EARLY attempts
+                // are much more aggressive — most blips recover within seconds.
+                const SCHEDULE_MS = [
+                    1_000, 3_000, 10_000, 30_000, 60_000,
+                    5 * 60_000, 5 * 60_000, 5 * 60_000, 5 * 60_000, 5 * 60_000,
+                ];
+                const SLOW_PROBE_MS = 30 * 60_000;
                 let attempts = 0;
                 const reconnectLoop = async () => {
                     attempts++;
                     try {
                         const reconnected = await this.connectToRunning();
                         if (reconnected) {
-                            logger.info({ attempts }, 'FalkorDB reconnected');
-                            return; // Success — stop the loop
+                            logger.info({ attempts, pid: process.pid }, 'FalkorDB reconnected');
+                            return;
                         }
                     }
-                    catch { /* retry */ }
-                    if (attempts < 5) {
-                        setTimeout(reconnectLoop, 30_000); // Retry in 30s
+                    catch (retryErr) {
+                        // Capture retry failures too — silent catch was hiding root cause
+                        const ri = extractErrorInfo(retryErr);
+                        logger.debug({ ...ri, attempts }, 'FalkorDB reconnect attempt failed');
                     }
-                    else if (attempts < 10) {
-                        setTimeout(reconnectLoop, 5 * 60_000); // Back off to 5 min
-                    }
-                    else {
-                        // Keep a slow background probe instead of giving up entirely
-                        logger.warn({ attempts }, 'FalkorDB reconnect entering slow probe (every 30 min)');
-                        setTimeout(reconnectLoop, 30 * 60_000);
+                    const delay = SCHEDULE_MS[attempts - 1] ?? SLOW_PROBE_MS;
+                    if (attempts === SCHEDULE_MS.length) {
+                        logger.warn({ attempts, pid: process.pid }, 'FalkorDB reconnect exhausted fast-retry schedule — entering slow probe (every 30 min)');
                     }
+                    setTimeout(reconnectLoop, delay);
                 };
-                setTimeout(reconnectLoop, 30_000);
+                setTimeout(reconnectLoop, SCHEDULE_MS[0]);
             });
             return true;
         }
-        catch {
+        catch (err) {
+            // Phase 13: log connect-time failures too (was swallowing them silently)
+            const errInfo = extractErrorInfo(err);
+            logger.debug({ ...errInfo, socketPath: this.socketFilePath }, 'FalkorDB initial connect failed');
             this.available = false;
             return false;
         }
@@ -151,7 +215,101 @@ export class GraphStore {
     isAvailable() {
         return this.available;
     }
+    // ── Liveness probe (daemon only — Phase 13) ──────────────────────────
+    /**
+     * Periodic health check on the owned embedded server. Runs every 60s.
+     * Pings with a trivial Cypher query (RETURN 1). Two consecutive failures
+     * trigger a restart attempt. Backs off after 3 restart attempts to avoid
+     * crash-loop noise — at that point graph features stay disabled until
+     * the daemon is manually restarted.
+     *
+     * Daemon-only because client processes have their own reconnect loop on
+     * the .on('error') path. The probe specifically catches the case where
+     * the server hangs (no error event but stops responding).
+     */
+    startLivenessProbe() {
+        if (this.livenessProbeTimer)
+            return;
+        const PROBE_INTERVAL_MS = 60_000;
+        const MAX_RESTART_ATTEMPTS = 3;
+        const probe = async () => {
+            if (!this.ownsServer)
+                return; // safety — only the server owner probes
+            if (!this.available || !this.graph) {
+                // Already disabled — let the existing recovery paths run.
+                return;
+            }
+            try {
+                await Promise.race([
+                    this.graph.query('RETURN 1 AS ping'),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('probe-timeout')), 5_000)),
+                ]);
+                // Probe succeeded — reset failure streak.
+                if (this.livenessFailureStreak > 0) {
+                    logger.info({ priorFailures: this.livenessFailureStreak }, 'FalkorDB liveness probe recovered');
+                    this.livenessFailureStreak = 0;
+                }
+            }
+            catch (err) {
+                this.livenessFailureStreak++;
+                logger.warn({ ...extractErrorInfo(err), streak: this.livenessFailureStreak }, 'FalkorDB liveness probe failed');
+                if (this.livenessFailureStreak >= 2) {
+                    await this.attemptServerRestart(MAX_RESTART_ATTEMPTS);
+                }
+            }
+        };
+        this.livenessProbeTimer = setInterval(probe, PROBE_INTERVAL_MS);
+        // Don't keep the daemon alive just for the probe.
+        this.livenessProbeTimer.unref?.();
+    }
+    async attemptServerRestart(maxAttempts) {
+        if (this.livenessRestartAttempts >= maxAttempts) {
+            logger.error({ attempts: this.livenessRestartAttempts }, 'FalkorDB restart attempts exhausted — graph features disabled until daemon restart');
+            this.available = false;
+            if (this.livenessProbeTimer) {
+                clearInterval(this.livenessProbeTimer);
+                this.livenessProbeTimer = null;
+            }
+            return;
+        }
+        this.livenessRestartAttempts++;
+        logger.warn({ attempt: this.livenessRestartAttempts, max: maxAttempts }, 'FalkorDB restart attempt');
+        try {
+            // Tear down the current server gracefully.
+            try {
+                await this.db?.close?.();
+            }
+            catch { /* ignore */ }
+            this.db = null;
+            this.graph = null;
+            this.available = false;
+            try {
+                unlinkSync(this.socketFilePath);
+            }
+            catch { /* ignore */ }
+            // Re-initialize. initialize() will re-register error handlers and
+            // re-start the probe — but we don't want to start a NESTED probe,
+            // so clear the timer first.
+            if (this.livenessProbeTimer) {
+                clearInterval(this.livenessProbeTimer);
+                this.livenessProbeTimer = null;
+            }
+            this.livenessFailureStreak = 0;
+            await this.initialize();
+            if (this.available) {
+                logger.info({ attempt: this.livenessRestartAttempts }, 'FalkorDB restart succeeded');
+            }
+        }
+        catch (err) {
+            logger.error(extractErrorInfo(err), 'FalkorDB restart attempt failed');
+        }
+    }
     async close() {
+        // Stop the liveness probe before tearing down (Phase 13).
+        if (this.livenessProbeTimer) {
+            clearInterval(this.livenessProbeTimer);
+            this.livenessProbeTimer = null;
+        }
         if (this.ownsServer && this.db) {
             // Clean up socket file
             try {

package/dist/tools/shared.d.ts

@@ -24,7 +24,6 @@ export declare const SOUL_FILE: string;
 export declare const IDENTITY_FILE: string;
 export declare const HEARTBEAT_FILE: string;
 export declare const CRON_FILE: string;
-export declare const PROFILES_DIR: string;
 export declare const AGENTS_DIR: string;
 export declare const TEAM_COMMS_LOG: string;
 export declare const HANDOFFS_DIR: string;

package/dist/tools/shared.js

@@ -10,27 +10,12 @@ import path from 'node:path';
 import pino from 'pino';
 // ── Paths ──────────────────────────────────────────────────────────────
 export const BASE_DIR = process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine');
+import { parseEnvText } from '../config/env-parser.js';
 function readEnvFile() {
     const envPath = path.join(BASE_DIR, '.env');
     if (!existsSync(envPath))
         return {};
-    const result = {};
-    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        const key = trimmed.slice(0, eqIndex);
-        let value = trimmed.slice(eqIndex + 1);
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        result[key] = value;
-    }
-    return result;
+    return parseEnvText(readFileSync(envPath, 'utf-8'));
 }
 export const env = readEnvFile();
 export const VAULT_DIR = path.join(BASE_DIR, 'vault');
@@ -50,7 +35,6 @@ export const SOUL_FILE = path.join(SYSTEM_DIR, 'SOUL.md');
 export const IDENTITY_FILE = path.join(SYSTEM_DIR, 'IDENTITY.md');
 export const HEARTBEAT_FILE = path.join(SYSTEM_DIR, 'HEARTBEAT.md');
 export const CRON_FILE = path.join(SYSTEM_DIR, 'CRON.md');
-export const PROFILES_DIR = path.join(SYSTEM_DIR, 'profiles');
 export const AGENTS_DIR = path.join(SYSTEM_DIR, 'agents');
 export const TEAM_COMMS_LOG = path.join(BASE_DIR, 'logs', 'team-comms.jsonl');
 export const HANDOFFS_DIR = path.join(BASE_DIR, 'handoffs');

package/dist/tools/team-tools.js

@@ -5,7 +5,7 @@ import { randomBytes } from 'node:crypto';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
-import { ACTIVE_AGENT_SLUG, AGENTS_DIR, BASE_DIR, DELEGATIONS_BASE, PROFILES_DIR, TEAM_COMMS_LOG, env, logger, parseTasks, textResult, } from './shared.js';
+import { ACTIVE_AGENT_SLUG, AGENTS_DIR, BASE_DIR, DELEGATIONS_BASE, TEAM_COMMS_LOG, env, logger, parseTasks, textResult, } from './shared.js';
 import { todayISO } from '../gateway/cron-scheduler.js';
 async function loadTeamAgents() {
     const matterMod = await import('gray-matter');
@@ -30,21 +30,9 @@ async function loadTeamAgents() {
         }
         catch { /* agents dir not readable */ }
     }
-    if (existsSync(PROFILES_DIR)) {
-        for (const file of readdirSync(PROFILES_DIR).filter(f => f.endsWith('.md') && !f.startsWith('_'))) {
-            try {
-                const slug = file.replace(/\.md$/, '');
-                if (seen.has(slug))
-                    continue;
-                const { data } = (await import('gray-matter')).default(readFileSync(path.join(PROFILES_DIR, file), 'utf-8'));
-                const channelName = data.channelName ? String(data.channelName) : '';
-                if (!channelName)
-                    continue;
-                agents.push({ slug, name: String(data.name ?? slug), channelName, canMessage: Array.isArray(data.canMessage) ? data.canMessage.map(String) : [], description: String(data.description ?? '') });
-            }
-            catch { /* skip */ }
-        }
-    }
+    // Phase 14: legacy PROFILES_DIR fallback removed — that directory has
+    // been empty in production for a long time and the new format
+    // (vault/00-System/agents/<slug>/agent.md) is the only source loaded above.
     return agents;
 }
 function assertAgentCrudAllowed(action) {

package/dist/vault-migrations/0005-create-clementine-json.js

@@ -11,28 +11,13 @@
  */
 import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { parseEnvText } from '../config/env-parser.js';
 /** Re-parse .env independently of config.ts's module-level cache. */
 function readEnv(baseDir) {
     const envPath = path.join(baseDir, '.env');
     if (!existsSync(envPath))
         return {};
-    const result = {};
-    for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        const key = trimmed.slice(0, eqIndex);
-        let value = trimmed.slice(eqIndex + 1);
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        result[key] = value;
-    }
-    return result;
+    return parseEnvText(readFileSync(envPath, 'utf-8'));
 }
 function num(v) {
     if (v === undefined || v === '')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",

package/dist/agent/profiles.d.ts

@@ -1,22 +0,0 @@
-/**
- * Clementine TypeScript — Agent profile management.
- *
- * Profiles are Markdown files with YAML frontmatter stored in
- * vault/00-System/profiles/. Each profile defines a persona with its own
- * tone, tool restrictions, security tier, and system prompt body.
- *
- * ProfileManager scans the directory, caches AgentProfile objects, and
- * hot-reloads when files change (60-second TTL).
- */
-import type { AgentProfile } from '../types.js';
-export declare class ProfileManager {
-    private dir;
-    private cache;
-    private cacheTime;
-    constructor(profilesDir: string);
-    private refreshIfStale;
-    private loadProfile;
-    get(slug: string): AgentProfile | null;
-    listAll(): AgentProfile[];
-}
-//# sourceMappingURL=profiles.d.ts.map

package/dist/agent/profiles.js

@@ -1,91 +0,0 @@
-/**
- * Clementine TypeScript — Agent profile management.
- *
- * Profiles are Markdown files with YAML frontmatter stored in
- * vault/00-System/profiles/. Each profile defines a persona with its own
- * tone, tool restrictions, security tier, and system prompt body.
- *
- * ProfileManager scans the directory, caches AgentProfile objects, and
- * hot-reloads when files change (60-second TTL).
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import matter from 'gray-matter';
-const CACHE_TTL_MS = 60_000;
-export class ProfileManager {
-    dir;
-    cache = new Map();
-    cacheTime = 0;
-    constructor(profilesDir) {
-        this.dir = profilesDir;
-    }
-    refreshIfStale() {
-        const now = Date.now();
-        if (now - this.cacheTime < CACHE_TTL_MS && this.cache.size > 0) {
-            return;
-        }
-        if (!fs.existsSync(this.dir)) {
-            this.cache.clear();
-            this.cacheTime = now;
-            return;
-        }
-        const profiles = new Map();
-        const files = fs.readdirSync(this.dir).filter((f) => f.endsWith('.md') && !f.startsWith('_')).sort();
-        for (const file of files) {
-            try {
-                const filePath = path.join(this.dir, file);
-                const profile = this.loadProfile(filePath, file);
-                const slug = file.replace(/\.md$/, '');
-                profiles.set(slug, profile);
-            }
-            catch {
-                // Skip malformed profile files
-            }
-        }
-        this.cache = profiles;
-        this.cacheTime = now;
-    }
-    loadProfile(filePath, fileName) {
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        const { data: meta, content } = matter(raw);
-        const slug = fileName.replace(/\.md$/, '');
-        // Cap tier at 2 — profiles can never grant Tier 3
-        const tier = Math.min(Number(meta.tier ?? 1), 2);
-        // Parse team-specific frontmatter
-        let team;
-        const channelName = Array.isArray(meta.channelName)
-            ? meta.channelName.map(String).filter(Boolean)
-            : meta.channelName ? String(meta.channelName) : undefined;
-        const canMessage = Array.isArray(meta.canMessage)
-            ? meta.canMessage.map(String).filter(Boolean)
-            : [];
-        const allowedTools = Array.isArray(meta.allowedTools)
-            ? meta.allowedTools.map(String).filter(Boolean)
-            : undefined;
-        if (channelName && (typeof channelName === 'string' || channelName.length > 0)) {
-            // channels[] populated at runtime by the agent's own bot
-            const teamChat = meta.teamChat === true || meta.teamChat === 'true';
-            const respondToAll = meta.respondToAll === true || meta.respondToAll === 'true';
-            team = { channelName, channels: [], canMessage, allowedTools, teamChat, respondToAll: respondToAll || undefined };
-        }
-        return {
-            slug,
-            name: String(meta.name ?? slug.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())),
-            tier,
-            description: String(meta.description ?? meta.role ?? ''),
-            systemPromptBody: content.trim(),
-            model: meta.model ? String(meta.model) : undefined,
-            avatar: meta.avatar ? String(meta.avatar) : undefined,
-            team,
-        };
-    }
-    get(slug) {
-        this.refreshIfStale();
-        return this.cache.get(slug) ?? null;
-    }
-    listAll() {
-        this.refreshIfStale();
-        return [...this.cache.values()];
-    }
-}
-//# sourceMappingURL=profiles.js.map