@aperdomoll90/ledger-ai 1.1.2 → 1.2.0

package/dist/cli.js

@@ -17,7 +17,7 @@ import { setupClaudeCode, setupOpenclaw, setupChatgpt } from './commands/setup.j
 import { backup, enableBackupCron, disableBackupCron } from './commands/backup.js';
 import { restore } from './commands/restore.js';
 import { onboard } from './commands/onboard.js';
-import { configGet, configSet, configList } from './commands/config.js';
+import { configGet, configSet, configUnset, configList } from './commands/config.js';
 import { migrate } from './commands/migrate.js';
 import { add } from './commands/add.js';
 import { update } from './commands/update.js';
@@ -133,7 +133,25 @@ configCmd
     .command('set <key> <value>')
     .description('Set a config value')
     .action(async (key, value) => {
-    await configSet(key, value);
+    if (key.startsWith('types.')) {
+        const config = loadConfig();
+        await configSet(key, value, { supabase: config.supabase, openai: config.openai });
+    }
+    else {
+        await configSet(key, value);
+    }
+});
+configCmd
+    .command('unset <key>')
+    .description('Remove a config override (types.* keys only)')
+    .action(async (key) => {
+    if (key.startsWith('types.')) {
+        const config = loadConfig();
+        await configUnset(key, { supabase: config.supabase, openai: config.openai });
+    }
+    else {
+        await configUnset(key);
+    }
 });
 configCmd
     .command('list')

package/dist/commands/add.js

@@ -1,5 +1,5 @@
 import { loadConfigFile } from '../lib/config.js';
-import { opAddNote, NOTE_TYPES, NOTE_STATUSES } from '../lib/notes.js';
+import { opAddNote, getRegisteredTypes, isRegisteredType, registerType, validateTypeName, inferDelivery, NOTE_STATUSES } from '../lib/notes.js';
 import { ask, confirm, choose } from '../lib/prompt.js';
 export async function add(config, content, options) {
     const configFile = loadConfigFile();
@@ -18,12 +18,37 @@ export async function add(config, content, options) {
     if (interactive && !options.force) {
         // Type
         if (!type) {
+            const registeredTypes = getRegisteredTypes();
             const typeChoice = await choose('What type of note is this?', [
-                ...NOTE_TYPES,
+                ...registeredTypes,
                 'skip — use default (general)',
             ]);
             type = typeChoice.startsWith('skip') ? 'general' : typeChoice;
         }
+        // Handle unknown type from --type flag
+        if (type && !isRegisteredType(type)) {
+            console.error(`\nType "${type}" is not registered.`);
+            const action = await choose('What would you like to do?', [
+                'register — register it now (pick a delivery tier)',
+                'existing — use an existing type instead',
+                'proceed — save anyway (defaults to "knowledge" delivery)',
+            ]);
+            if (action.startsWith('register')) {
+                const nameError = validateTypeName(type);
+                if (nameError) {
+                    console.error(nameError);
+                    process.exit(1);
+                }
+                const deliveryChoice = await choose('Delivery tier?', ['persona', 'project', 'knowledge']);
+                registerType(type, deliveryChoice);
+                console.error(`Registered type "${type}" with delivery "${deliveryChoice}".`);
+            }
+            else if (action.startsWith('existing')) {
+                const registeredTypes = getRegisteredTypes();
+                type = await choose('Choose a type:', registeredTypes);
+            }
+            // 'proceed' — use the type as-is, will default to knowledge delivery
+        }
         // Description
         if (!metadata.description) {
             const desc = await ask('One-line description (what is this note for?): ');
@@ -43,8 +68,7 @@ export async function add(config, content, options) {
                 metadata.project = proj;
         }
         // Status (only for project-scoped types)
-        const projectTypes = ['architecture-decision', 'project-status', 'event', 'error'];
-        if (projectTypes.includes(type) && !metadata.status) {
+        if (inferDelivery(type) === 'project' && !metadata.status) {
             const statusChoice = await choose('What stage is this?', [
                 ...NOTE_STATUSES,
                 'skip — no status',

package/dist/commands/config.js

@@ -1,22 +1,8 @@
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { getLedgerDir, saveConfigFile, loadConfigFile } from '../lib/config.js';
+import { BUILTIN_TYPES, getTypeRegistry, opUpdateMetadata, validateTypeName } from '../lib/notes.js';
+import { choose, confirm } from '../lib/prompt.js';
 import { resolve } from 'path';
-import { getLedgerDir } from '../lib/config.js';
-import { confirm } from '../lib/prompt.js';
 const CONFIG_PATH = resolve(getLedgerDir(), 'config.json');
-function loadFullConfig() {
-    if (existsSync(CONFIG_PATH)) {
-        try {
-            return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-        }
-        catch {
-            return {};
-        }
-    }
-    return {};
-}
-function saveConfig(config) {
-    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
-}
 const SECURITY_WARNINGS = {
     envBlocking: 'This disables .env file protection.\nYour API keys and credentials will be readable by the AI agent.',
     mcpJsonBlocking: 'This allows direct editing of mcp.json.\nMCP servers should be registered via `claude mcp add`, not by editing config files.',
@@ -27,8 +13,15 @@ const DESCRIPTIONS = {
     writeInterception: 'Auto-ingest files written to memory directory into Ledger',
     sessionEndCheck: 'Check for unsynced files at session end',
 };
+const NAMING_DESCRIPTIONS = {
+    'naming.enforce': 'Validate upsert_key format on note creation',
+    'naming.interactive': 'Prompt for missing metadata when creating notes (default: true)',
+};
+const DEVICE_DESCRIPTIONS = {
+    'device.alias': 'Name for this device',
+};
 export async function configGet(key) {
-    const config = loadFullConfig();
+    const config = loadConfigFile();
     if (key === 'all') {
         console.log(JSON.stringify(config, null, 2));
         return;
@@ -44,6 +37,20 @@ export async function configGet(key) {
         console.log(`${key}: ${config[key]}`);
         return;
     }
+    // Check naming settings
+    if (key === 'naming.enforce') {
+        console.log(`naming.enforce: ${config.naming?.enforce ?? false}`);
+        return;
+    }
+    if (key === 'naming.interactive') {
+        console.log(`naming.interactive: ${config.naming?.interactive ?? true} (default: true)`);
+        return;
+    }
+    // Check device
+    if (key === 'device.alias') {
+        console.log(`device.alias: ${config.device?.alias || '(not set)'}`);
+        return;
+    }
     // Show default
     const defaults = {
         envBlocking: true,
@@ -55,12 +62,42 @@ export async function configGet(key) {
         console.log(`${key}: ${defaults[key]} (default)`);
         return;
     }
+    // Handle type registry
+    if (key === 'types') {
+        const registry = getTypeRegistry();
+        const userTypes = config.types ?? {};
+        console.error('Type registry:');
+        for (const [typeName, delivery] of Object.entries(registry)) {
+            const isBuiltin = typeName in BUILTIN_TYPES;
+            const isOverridden = isBuiltin && typeName in userTypes;
+            const isCustom = !isBuiltin;
+            let annotation = isCustom ? '(custom)' : '(built-in)';
+            if (isOverridden) {
+                annotation = `(built-in, overridden — default: ${BUILTIN_TYPES[typeName]})`;
+            }
+            console.error(`  ${typeName}: ${delivery} ${annotation}`);
+        }
+        return;
+    }
+    if (key.startsWith('types.')) {
+        const typeName = key.slice(6);
+        const registry = getTypeRegistry();
+        if (typeName in registry) {
+            const isBuiltin = typeName in BUILTIN_TYPES;
+            console.log(`${typeName}: ${registry[typeName]} (${isBuiltin ? 'built-in' : 'custom'})`);
+        }
+        else {
+            console.log(`${typeName}: not registered`);
+        }
+        return;
+    }
+    const allKeys = [...Object.keys(DESCRIPTIONS), ...Object.keys(NAMING_DESCRIPTIONS), ...Object.keys(DEVICE_DESCRIPTIONS), 'memoryDir', 'claudeMdPath', 'types', 'all'];
     console.error(`Unknown config key: ${key}`);
-    console.error(`Available: ${Object.keys(DESCRIPTIONS).join(', ')}, memoryDir, claudeMdPath, all`);
+    console.error(`Available: ${allKeys.join(', ')}`);
     process.exit(1);
 }
-export async function configSet(key, value) {
-    const config = loadFullConfig();
+export async function configSet(key, value, clients) {
+    const config = loadConfigFile();
     // Handle hook settings
     const hookKeys = ['envBlocking', 'mcpJsonBlocking', 'writeInterception', 'sessionEndCheck'];
     if (hookKeys.includes(key)) {
@@ -82,25 +119,146 @@ export async function configSet(key, value) {
         if (!config.hooks)
             config.hooks = {};
         config.hooks[key] = boolValue;
-        saveConfig(config);
+        saveConfigFile(config);
         const state = boolValue ? 'enabled' : 'disabled';
         console.error(`${key}: ${state}`);
         console.error('Run `ledger setup claude-code` to apply hook changes.');
         return;
     }
+    // Handle naming settings
+    const namingKeys = ['naming.enforce', 'naming.interactive'];
+    if (namingKeys.includes(key)) {
+        const boolValue = value === 'true';
+        if (!config.naming)
+            config.naming = {};
+        const field = key.split('.')[1];
+        config.naming[field] = boolValue;
+        saveConfigFile(config);
+        console.error(`${key}: ${boolValue ? 'enabled' : 'disabled'}`);
+        return;
+    }
+    // Handle device alias
+    if (key === 'device.alias') {
+        config.device = { alias: value };
+        saveConfigFile(config);
+        console.error(`device.alias: ${value}`);
+        return;
+    }
     // Handle path settings
     if (key === 'memoryDir' || key === 'claudeMdPath') {
         config[key] = value;
-        saveConfig(config);
+        saveConfigFile(config);
         console.error(`${key}: ${value}`);
         return;
     }
+    // Handle type registry
+    if (key.startsWith('types.')) {
+        const typeName = key.slice(6);
+        const delivery = value;
+        if (!['persona', 'project', 'knowledge'].includes(delivery)) {
+            console.error(`Invalid delivery tier: "${value}". Must be: persona, project, or knowledge.`);
+            process.exit(1);
+        }
+        const nameError = validateTypeName(typeName);
+        if (nameError) {
+            console.error(nameError);
+            process.exit(1);
+        }
+        const oldDelivery = config.types?.[typeName] ?? BUILTIN_TYPES[typeName];
+        if (!config.types)
+            config.types = {};
+        config.types[typeName] = delivery;
+        saveConfigFile(config);
+        const isBuiltin = typeName in BUILTIN_TYPES;
+        const action = isBuiltin ? 'overridden' : 'registered';
+        console.error(`types.${typeName}: ${delivery} (${action})`);
+        // Delivery change propagation — only if we have DB access and delivery actually changed
+        if (clients && oldDelivery && oldDelivery !== delivery) {
+            const { data: notes } = await clients.supabase
+                .from('notes')
+                .select('id, metadata')
+                .eq('metadata->>type', typeName);
+            const affected = (notes ?? []).filter((n) => n.metadata.delivery !== delivery);
+            if (affected.length > 0) {
+                console.error(`\n${affected.length} note(s) currently have a different delivery:`);
+                for (const note of affected) {
+                    const meta = note.metadata;
+                    const uKey = meta.upsert_key || `id-${note.id}`;
+                    console.error(`  [${note.id}] ${uKey} — delivery: ${meta.delivery}`);
+                }
+                const action = await choose('\nUpdate delivery on these notes?', [
+                    'all — update all notes',
+                    'select — choose individually',
+                    'none — only affect new notes',
+                ]);
+                if (action.startsWith('all')) {
+                    for (const note of affected) {
+                        await opUpdateMetadata(clients, note.id, { delivery });
+                    }
+                    console.error(`Updated delivery to "${delivery}" on ${affected.length} note(s).`);
+                }
+                else if (action.startsWith('select')) {
+                    let updated = 0;
+                    for (const note of affected) {
+                        const meta = note.metadata;
+                        const uKey = meta.upsert_key || `id-${note.id}`;
+                        const yes = await confirm(`  Update [${note.id}] ${uKey}?`);
+                        if (yes) {
+                            await opUpdateMetadata(clients, note.id, { delivery });
+                            updated++;
+                        }
+                    }
+                    console.error(`Updated delivery on ${updated} note(s).`);
+                }
+            }
+        }
+        return;
+    }
+    const allKeys = [...hookKeys, ...namingKeys, 'device.alias', 'memoryDir', 'claudeMdPath', 'types.*'];
     console.error(`Unknown config key: ${key}`);
-    console.error(`Available: ${hookKeys.join(', ')}, memoryDir, claudeMdPath`);
+    console.error(`Available: ${allKeys.join(', ')}`);
     process.exit(1);
 }
+export async function configUnset(key, clients) {
+    if (!key.startsWith('types.')) {
+        console.error(`Unset is only supported for types.* keys. Got: ${key}`);
+        process.exit(1);
+    }
+    const typeName = key.slice(6);
+    const config = loadConfigFile();
+    const userTypes = config.types ?? {};
+    if (!(typeName in userTypes)) {
+        console.error(`No user override for "${typeName}".`);
+        return;
+    }
+    const isBuiltin = typeName in BUILTIN_TYPES;
+    if (!isBuiltin && clients) {
+        const { data: notes } = await clients.supabase
+            .from('notes')
+            .select('id')
+            .eq('metadata->>type', typeName);
+        if (notes && notes.length > 0) {
+            console.error(`\n${notes.length} note(s) use type "${typeName}". They will become unregistered (delivery defaults to "knowledge").`);
+            const proceed = await confirm('Proceed?');
+            if (!proceed) {
+                console.error('Cancelled.');
+                return;
+            }
+        }
+    }
+    delete config.types[typeName];
+    if (config.types && Object.keys(config.types).length === 0)
+        delete config.types;
+    saveConfigFile(config);
+    if (isBuiltin) {
+        console.error(`Reverted "${typeName}" to built-in default: ${BUILTIN_TYPES[typeName]}`);
+    }
+    else {
+        console.error(`Removed custom type "${typeName}".`);
+    }
+}
 export async function configList() {
-    const config = loadFullConfig();
+    const config = loadConfigFile();
     const hooks = config.hooks || {};
     console.error('Hook settings:');
     for (const [key, desc] of Object.entries(DESCRIPTIONS)) {
@@ -108,8 +266,33 @@ export async function configList() {
         const state = value ? 'enabled' : 'DISABLED';
         console.error(`  ${key}: ${state} — ${desc}`);
     }
+    console.error('\nNaming settings:');
+    for (const [key, desc] of Object.entries(NAMING_DESCRIPTIONS)) {
+        const field = key.split('.')[1];
+        const defaultVal = field === 'interactive' ? true : false;
+        const value = config.naming?.[field] ?? defaultVal;
+        const state = value ? 'enabled' : 'DISABLED';
+        console.error(`  ${key}: ${state} — ${desc}`);
+    }
+    console.error('\nDevice:');
+    console.error(`  device.alias: ${config.device?.alias || '(not set)'}`);
     console.error('\nPaths:');
     console.error(`  memoryDir: ${config.memoryDir || '(default)'}`);
     console.error(`  claudeMdPath: ${config.claudeMdPath || '(default)'}`);
+    const registry = getTypeRegistry();
+    const userTypes = config.types ?? {};
+    const customTypes = Object.keys(userTypes).filter(t => !(t in BUILTIN_TYPES));
+    const overrides = Object.keys(userTypes).filter(t => t in BUILTIN_TYPES);
+    console.error('\nType registry:');
+    if (customTypes.length > 0) {
+        console.error(`  Custom types: ${customTypes.map(t => `${t} (${userTypes[t]})`).join(', ')}`);
+    }
+    if (overrides.length > 0) {
+        console.error(`  Overrides: ${overrides.map(t => `${t}: ${userTypes[t]} (default: ${BUILTIN_TYPES[t]})`).join(', ')}`);
+    }
+    if (customTypes.length === 0 && overrides.length === 0) {
+        console.error('  No custom types or overrides. Using built-in defaults.');
+    }
+    console.error(`  Built-in types: ${Object.keys(BUILTIN_TYPES).length}`);
     console.error('\nConfig file: ' + CONFIG_PATH);
 }

package/dist/commands/sync.js

@@ -1,6 +1,7 @@
 import { writeFileSync, readFileSync, mkdirSync, existsSync, unlinkSync, readdirSync } from 'fs';
 import { resolve } from 'path';
-import { fetchPersonaNotes, updateNoteContent, updateNoteHash } from '../lib/notes.js';
+import { loadConfigFile, saveConfigFile } from '../lib/config.js';
+import { fetchPersonaNotes, updateNoteContent, updateNoteHash, opAddNote } from '../lib/notes.js';
 import { contentHash } from '../lib/hash.js';
 import { generateClaudeMd, generateMemoryMd } from '../lib/generators.js';
 import { confirm } from '../lib/prompt.js';
@@ -20,6 +21,8 @@ export async function sync(config, options) {
         return result;
     }
     mkdirSync(config.memoryDir, { recursive: true });
+    // --- Phase 0: Sync type registry ---
+    await syncTypeRegistryPull(config, quiet, force, dryRun);
     const notesByFile = new Map();
     for (const note of notes) {
         const localFile = note.metadata.local_file;
@@ -191,6 +194,8 @@ export async function sync(config, options) {
                 console.error('  wrote ~/CLAUDE.md');
         }
     }
+    // --- Phase 3.5: Push type registry ---
+    await syncTypeRegistryPush(config, quiet, dryRun);
     // --- Summary ---
     if (!quiet) {
         const parts = [
@@ -204,3 +209,69 @@ export async function sync(config, options) {
     }
     return result;
 }
+export async function syncTypeRegistryPush(config, quiet, dryRun) {
+    const configFile = loadConfigFile();
+    const userTypes = configFile.types;
+    if (!userTypes || Object.keys(userTypes).length === 0) {
+        return; // Nothing to push
+    }
+    const content = JSON.stringify(userTypes, null, 2);
+    const clients = { supabase: config.supabase, openai: config.openai };
+    if (dryRun) {
+        if (!quiet)
+            console.error('  type-registry — would push to Ledger');
+        return;
+    }
+    await opAddNote(clients, content, 'system-rule', 'ledger-sync', {
+        upsert_key: 'system-rule-type-registry',
+        description: 'User-defined type registry overrides. Managed by ledger sync.',
+        delivery: 'persona',
+        scope: 'system',
+        interactive_skip: true,
+    }, true); // force: true to skip duplicate guard
+    if (!quiet)
+        console.error('  type-registry — pushed to Ledger');
+}
+export async function syncTypeRegistryPull(config, quiet, force, dryRun) {
+    const { data: note } = await config.supabase
+        .from('notes')
+        .select('content')
+        .eq('metadata->>upsert_key', 'system-rule-type-registry')
+        .limit(1)
+        .single();
+    if (!note)
+        return; // No remote type registry
+    let remoteTypes;
+    try {
+        remoteTypes = JSON.parse(note.content);
+    }
+    catch {
+        if (!quiet)
+            console.error('  type-registry — invalid JSON in remote note, skipping');
+        return;
+    }
+    const configFile = loadConfigFile();
+    const localTypes = configFile.types ?? {};
+    // Merge: local wins unless --force
+    const merged = force
+        ? { ...localTypes, ...remoteTypes }
+        : { ...remoteTypes, ...localTypes };
+    // Check if anything changed
+    const localJson = JSON.stringify(localTypes, Object.keys(localTypes).sort());
+    const mergedJson = JSON.stringify(merged, Object.keys(merged).sort());
+    if (localJson === mergedJson)
+        return; // No changes
+    if (dryRun) {
+        const newKeys = Object.keys(merged).filter(k => !(k in localTypes));
+        if (newKeys.length > 0 && !quiet) {
+            console.error(`  type-registry — would add: ${newKeys.map(k => `${k} (${merged[k]})`).join(', ')}`);
+        }
+        return;
+    }
+    configFile.types = merged;
+    saveConfigFile(configFile);
+    const newKeys = Object.keys(merged).filter(k => !(k in localTypes));
+    if (newKeys.length > 0 && !quiet) {
+        console.error(`  type-registry synced: added ${newKeys.map(k => `${k} (${merged[k]})`).join(', ')}`);
+    }
+}

package/dist/lib/config.js

@@ -3,7 +3,7 @@ import { createClient } from '@supabase/supabase-js';
 import OpenAI from 'openai';
 import { resolve } from 'path';
 import { homedir } from 'os';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { fatal, ExitCode } from './errors.js';
 // --- Defaults ---
 const LEDGER_DIR = resolve(homedir(), '.ledger');
@@ -28,6 +28,11 @@ export function loadConfigFile() {
     }
     return {};
 }
+export function saveConfigFile(config) {
+    const configPath = resolve(getLedgerDir(), 'config.json');
+    mkdirSync(getLedgerDir(), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
 export function getDefaultConfig() {
     return {
         memoryDir: DEFAULT_MEMORY_DIR,

package/dist/lib/notes.js

@@ -1,19 +1,60 @@
 import { randomUUID } from 'crypto';
 import { fatal, ExitCode } from './errors.js';
 import { contentHash } from './hash.js';
-import { loadConfigFile } from './config.js';
-const DELIVERY_BY_TYPE = {
+import { loadConfigFile, saveConfigFile } from './config.js';
+// --- Built-in Type Registry ---
+export const BUILTIN_TYPES = {
     'user-preference': 'persona',
-    'feedback': 'persona',
+    'persona-rule': 'persona',
+    'system-rule': 'persona',
+    'code-craft': 'persona',
     'architecture-decision': 'project',
     'project-status': 'project',
-    'error': 'project',
     'event': 'project',
+    'error': 'project',
     'reference': 'knowledge',
+    'knowledge-guide': 'knowledge',
     'general': 'knowledge',
 };
+const TYPE_ALIASES = {
+    'feedback': 'general',
+};
+function resolveTypeAlias(type) {
+    return TYPE_ALIASES[type] ?? type;
+}
+export function getTypeRegistry() {
+    const config = loadConfigFile();
+    return { ...BUILTIN_TYPES, ...(config.types ?? {}) };
+}
 export function inferDelivery(noteType) {
-    return DELIVERY_BY_TYPE[noteType] ?? 'knowledge';
+    const resolved = resolveTypeAlias(noteType);
+    return getTypeRegistry()[resolved] ?? 'knowledge';
+}
+export function getRegisteredTypes() {
+    return Object.keys(getTypeRegistry());
+}
+export function isRegisteredType(noteType) {
+    const resolved = resolveTypeAlias(noteType);
+    return resolved in getTypeRegistry();
+}
+export function registerType(name, delivery) {
+    const config = loadConfigFile();
+    if (!config.types)
+        config.types = {};
+    config.types[name] = delivery;
+    saveConfigFile(config);
+}
+export function validateTypeName(name) {
+    if (!name || name.length < 2) {
+        return `Type name must be at least 2 characters. Got ${name.length}.`;
+    }
+    if (name.length > 50) {
+        return `Type name must be 50 characters or fewer. Got ${name.length}.`;
+    }
+    if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name)) {
+        return `Invalid type name "${name}". Use lowercase alphanumeric + hyphens, starting with a letter (e.g., "wine-log").`;
+    }
+    return null;
 }
 // --- Queries ---
 export async function fetchPersonaNotes(supabase) {
@@ -164,12 +205,16 @@ function formatNotePreview(id, meta, content, maxLen = 300) {
 const TYPE_PREFIXES = {
     'feedback': ['feedback'],
     'user-preference': ['user'],
+    'persona-rule': ['persona-rule'],
+    'system-rule': ['system-rule'],
+    'code-craft': ['code-craft'],
     'architecture-decision': ['spec', 'architecture'],
     'project-status': ['project-status'],
     'reference': ['reference'],
     'event': ['devlog', 'event'],
     'error': ['errorlog', 'error'],
     'general': ['general'],
+    'knowledge-guide': ['knowledge-guide'],
 };
 /**
  * Validate upsert_key format: {prefix}-{topic} or {project}-{prefix}-{topic}
@@ -224,18 +269,6 @@ function isInteractive() {
     const config = loadConfigFile();
     return config.naming?.interactive !== false;
 }
-/** Valid note types for the interactive prompt. */
-export const NOTE_TYPES = [
-    'user-preference',
-    'feedback',
-    'architecture-decision',
-    'project-status',
-    'reference',
-    'event',
-    'error',
-    'knowledge-guide',
-    'general',
-];
 /** Valid statuses for notes. */
 export const NOTE_STATUSES = ['idea', 'planning', 'active', 'done'];
 /**
@@ -251,8 +284,7 @@ export function checkMetadataCompleteness(metadata, type) {
         missing.push('upsert_key');
     }
     // Only ask for status on project-scoped types
-    const projectTypes = ['architecture-decision', 'project-status', 'event', 'error'];
-    if (projectTypes.includes(type) && !metadata.status) {
+    if (inferDelivery(type) === 'project' && !metadata.status) {
         missing.push('status');
     }
     if (missing.length === 0)
@@ -367,7 +399,7 @@ export async function opListNotes(clients, limit, type, project) {
     }).join('\n\n---\n\n');
     return { status: 'ok', message: formatted };
 }
-export async function opAddNote(clients, content, type, agent, metadata, force) {
+export async function opAddNote(clients, content, type, agent, metadata, force, registerTypeFlag) {
     const upsertKey = metadata.upsert_key;
     const description = metadata.description;
     const skippedInteractive = metadata.interactive_skip === true;
@@ -381,6 +413,29 @@ export async function opAddNote(clients, content, type, agent, metadata, force)
     }
     // Clean up the skip flag before saving
     delete metadata.interactive_skip;
+    // --- Type resolution and registration ---
+    const resolvedType = resolveTypeAlias(type);
+    // If register_type flag is set and type is unknown, register it
+    if (registerTypeFlag && !isRegisteredType(resolvedType)) {
+        const nameError = validateTypeName(resolvedType);
+        if (nameError)
+            return { status: 'error', message: nameError };
+        const delivery = metadata.delivery || 'knowledge';
+        registerType(resolvedType, delivery);
+    }
+    // If type is still unknown after potential registration, prompt
+    if (!isRegisteredType(resolvedType)) {
+        const registry = getTypeRegistry();
+        const typeListStr = Object.entries(registry)
+            .map(([t, d]) => `${t} (${d})`)
+            .join(', ');
+        return {
+            status: 'confirm',
+            message: `Type "${type}" is not registered.\n\nOptions:\n1. Register with delivery "knowledge" (default) — re-call add_note with register_type: true\n2. Register with specific delivery — re-call add_note with register_type: true AND set metadata.delivery to "persona", "project", or "knowledge"\n3. Use an existing type instead — re-call add_note with one of: ${typeListStr}\n4. Cancel\n\nAsk the user which option they prefer.`,
+        };
+    }
+    // Use resolved type for the rest of the flow
+    type = resolvedType;
     // Naming enforcement (opt-in via config)
     if (isNamingEnforced()) {
         const namingError = validateNaming(upsertKey || '', type, description);

package/dist/mcp-server.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { createClient } from '@supabase/supabase-js';
 import OpenAI from 'openai';
 import { z } from 'zod';
-import { opSearchNotes, opListNotes, opAddNote, opUpdateNote, opUpdateMetadata, opDeleteNote, } from './lib/notes.js';
+import { opSearchNotes, opListNotes, opAddNote, opUpdateNote, opUpdateMetadata, opDeleteNote, getTypeRegistry, } from './lib/notes.js';
 // --- Clients ---
 const supabaseUrl = process.env.SUPABASE_URL;
 const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
@@ -21,6 +21,11 @@ const clients = {
     supabase: createClient(supabaseUrl, supabaseKey),
     openai: new OpenAI({ apiKey: openaiKey }),
 };
+// Build dynamic type description from registry
+const typeRegistry = getTypeRegistry();
+const typeList = Object.entries(typeRegistry)
+    .map(([t, d]) => `${t} (${d})`)
+    .join(', ');
 // --- MCP Server ---
 const server = new McpServer({
     name: 'ledger',
@@ -40,12 +45,13 @@ server.tool('search_notes', 'Search memories by meaning using semantic similarit
 // Tool: Add a new note
 server.tool('add_note', 'Save a new memory/note to the knowledge base. Large notes are automatically chunked for embedding. Use upsert_key in metadata to update an existing note instead of creating a duplicate.', {
     content: z.string().describe('The note content to save'),
-    type: z.enum(['user-preference', 'feedback', 'architecture-decision', 'project-status', 'reference', 'event', 'error', 'knowledge-guide', 'general']).describe('Note type for consistent categorization'),
+    type: z.string().describe(`Note type. Registered: ${typeList}. Unknown types will prompt for registration.`),
     agent: z.string().describe('Which agent is saving this note (e.g. claude-code, zhuli)'),
     metadata: z.record(z.string(), z.unknown()).default({}).describe('Optional metadata (project, local_file, upsert_key, etc.)'),
     force: z.boolean().default(false).describe('Skip duplicate check and force creation of a new note'),
-}, async ({ content, type, agent, metadata, force }) => {
-    const result = await opAddNote(clients, content, type, agent, metadata, force);
+    register_type: z.boolean().default(false).describe('Set to true to register an unknown type before saving. Pass delivery in metadata if not using default (knowledge).'),
+}, async ({ content, type, agent, metadata, force, register_type }) => {
+    const result = await opAddNote(clients, content, type, agent, metadata, force, register_type);
     return { content: [{ type: 'text', text: result.message }] };
 });
 // Tool: Update an existing note by ID

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aperdomoll90/ledger-ai",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "AI identity and memory system — portable persona, knowledge sync, semantic search across agents and devices",
   "type": "module",
   "bin": {