instar 0.6.13 → 0.6.14

package/README.md

@@ -100,6 +100,35 @@ instar feedback --type bug --title "Session timeout" --description "Details..."
 - **[Behavioral Hooks](#behavioral-hooks)** -- Structural guardrails: identity injection, dangerous command guards, grounding before messaging.
 - **[Default Coherence Jobs](#default-coherence-jobs)** -- Health checks, reflection, relationship maintenance. A circadian rhythm out of the box.
 - **[Feedback Loop](#the-feedback-loop-a-rising-tide-lifts-all-ships)** -- Your agent reports issues, we fix them, every agent gets the update. A rising tide lifts all ships.
+- **[Agent Skills](#agent-skills)** -- 10 open-source skills for the [Agent Skills standard](https://agentskills.io). Use standalone or as an on-ramp to full Instar.
+
+## Agent Skills
+
+Instar ships 10 skills that follow the [Agent Skills open standard](https://agentskills.io) -- portable across Claude Code, Codex, Cursor, VS Code, and 35+ other platforms.
+
+**Standalone skills** work with zero dependencies. Copy a SKILL.md into your project and go:
+
+| Skill | What it does |
+|-------|-------------|
+| [agent-identity](skills/agent-identity/) | Set up persistent identity files so your agent knows who it is across sessions |
+| [agent-memory](skills/agent-memory/) | Teach cross-session memory patterns using MEMORY.md |
+| [command-guard](skills/command-guard/) | PreToolUse hook that blocks `rm -rf`, force push, database drops before they execute |
+| [credential-leak-detector](skills/credential-leak-detector/) | PostToolUse hook that scans output for 14 credential patterns -- blocks, redacts, or warns |
+| [smart-web-fetch](skills/smart-web-fetch/) | Fetch web content with automatic markdown conversion and intelligent extraction |
+
+**Instar-powered skills** unlock capabilities that need persistent infrastructure:
+
+| Skill | What it does |
+|-------|-------------|
+| [instar-scheduler](skills/instar-scheduler/) | Schedule recurring tasks on cron -- your agent works while you sleep |
+| [instar-session](skills/instar-session/) | Spawn parallel background sessions for deep work |
+| [instar-telegram](skills/instar-telegram/) | Two-way Telegram messaging -- your agent reaches out to you |
+| [instar-identity](skills/instar-identity/) | Identity that survives context compaction -- grounding hooks, not just files |
+| [instar-feedback](skills/instar-feedback/) | Report issues directly to the Instar maintainers from inside your agent |
+
+Each standalone skill includes a "Going Further" section showing how Instar transforms the capability from manual to autonomous. Each Instar-powered skill gracefully detects missing Instar and offers one-command setup.
+
+Browse all skills: [agent-skills.md/authors/sagemindai](https://agent-skills.md/authors/sagemindai)
 
 ## How It Works
 

package/dist/commands/init.js

@@ -1336,15 +1336,6 @@ fi
 # For startup/resume/clear — output a compact orientation
 echo "=== SESSION START ==="
 
-# Telegram-spawned session awareness
-# When auto-created for a Telegram topic, prime the agent to respond immediately
-if [ -n "\$INSTAR_TELEGRAM_TOPIC" ]; then
-  echo ""
-  echo "This session was auto-spawned for Telegram topic \$INSTAR_TELEGRAM_TOPIC."
-  echo "A message from your user triggered this session and will arrive momentarily."
-  echo "IMMEDIATELY acknowledge it via your Telegram relay — they are waiting."
-fi
-
 # Identity summary (first 20 lines of AGENT.md — enough for name + role)
 if [ -f "$INSTAR_DIR/AGENT.md" ]; then
   echo ""

package/dist/commands/server.js

@@ -18,8 +18,6 @@ import { JobScheduler } from '../scheduler/JobScheduler.js';
 import { AgentServer } from '../server/AgentServer.js';
 import { TelegramAdapter } from '../messaging/TelegramAdapter.js';
 import { RelationshipManager } from '../core/RelationshipManager.js';
-import { ClaudeCliIntelligenceProvider } from '../core/ClaudeCliIntelligenceProvider.js';
-import { AnthropicIntelligenceProvider } from '../core/AnthropicIntelligenceProvider.js';
 import { FeedbackManager } from '../core/FeedbackManager.js';
 import { DispatchManager } from '../core/DispatchManager.js';
 import { UpdateChecker } from '../core/UpdateChecker.js';
@@ -27,7 +25,6 @@ import { registerPort, unregisterPort, startHeartbeat } from '../core/PortRegist
 import { TelegraphService } from '../publishing/TelegraphService.js';
 import { PrivateViewer } from '../publishing/PrivateViewer.js';
 import { TunnelManager } from '../tunnel/TunnelManager.js';
-import { EvolutionManager } from '../core/EvolutionManager.js';
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
@@ -221,9 +218,9 @@ function wireTelegramRouting(telegram, sessionManager) {
             const ctxPath = path.join(tmpDir, `ctx-${topicId}-${Date.now()}.txt`);
             fs.writeFileSync(ctxPath, contextLines.join('\n'));
             const bootstrapMessage = `[telegram:${topicId}] ${text} (IMPORTANT: Read ${ctxPath} for Telegram relay instructions — you MUST relay your response back.)`;
-            sessionManager.spawnInteractiveSession(bootstrapMessage, storedName, { telegramTopicId: topicId }).then((newSessionName) => {
+            sessionManager.spawnInteractiveSession(bootstrapMessage, storedName).then((newSessionName) => {
                 telegram.registerTopicSession(topicId, newSessionName);
-                telegram.sendToTopic(topicId, `Session starting up — reading your message now. One moment.`).catch(() => { });
+                telegram.sendToTopic(topicId, `Session created.`).catch(() => { });
                 console.log(`[telegram→session] Auto-spawned "${newSessionName}" for topic ${topicId}`);
             }).catch((err) => {
                 console.error(`[telegram→session] Auto-spawn failed:`, err);
@@ -354,32 +351,8 @@ export async function startServer(options) {
         const sessionManager = new SessionManager(config.sessions, state);
         let relationships;
         if (config.relationships) {
-            // Wire LLM intelligence for identity resolution.
-            // Priority: Claude CLI (subscription, zero extra cost) > Anthropic API (explicit opt-in only)
-            const claudePath = config.sessions.claudePath;
-            let intelligenceMode = 'heuristic-only';
-            // Check if user explicitly opted into API-based intelligence
-            // (intelligenceProvider is a config-file-only field, not in the TypeScript type)
-            const explicitProvider = config.relationships.intelligenceProvider;
-            if (explicitProvider === 'anthropic-api') {
-                // User explicitly chose API — respect their decision
-                const apiProvider = AnthropicIntelligenceProvider.fromEnv();
-                if (apiProvider) {
-                    config.relationships.intelligence = apiProvider;
-                    intelligenceMode = 'LLM-supervised (Anthropic API — user choice)';
-                }
-                else {
-                    console.log(pc.yellow('  intelligenceProvider: "anthropic-api" set but ANTHROPIC_API_KEY not found'));
-                }
-            }
-            else if (claudePath) {
-                // Default: use Claude CLI via subscription (zero extra cost)
-                config.relationships.intelligence = new ClaudeCliIntelligenceProvider(claudePath);
-                intelligenceMode = 'LLM-supervised (Claude CLI subscription)';
-            }
             relationships = new RelationshipManager(config.relationships);
-            const count = relationships.getAll().length;
-            console.log(pc.green(`  Relationships loaded: ${count} tracked (${intelligenceMode})`));
+            console.log(pc.green(`  Relationships loaded: ${relationships.getAll().length} tracked`));
         }
         let scheduler;
         if (config.scheduler.enabled) {
@@ -481,13 +454,7 @@ export async function startServer(options) {
                 stateDir: config.stateDir,
             });
         }
-        // Set up evolution system (always enabled — the feedback loop infrastructure)
-        const evolution = new EvolutionManager({
-            stateDir: config.stateDir,
-            ...(config.evolution || {}),
-        });
-        console.log(pc.green('  Evolution system enabled'));
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, publisher, viewer, tunnel, evolution });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, publisher, viewer, tunnel });
         await server.start();
         // Start tunnel AFTER server is listening
         if (tunnel) {

package/dist/core/RelationshipManager.d.ts

@@ -16,16 +16,8 @@ export declare class RelationshipManager {
     private relationships;
     /** Maps "channel_type:identifier" -> relationship ID for cross-platform resolution */
     private channelIndex;
-    /** Maps normalized name -> set of relationship IDs for fuzzy name resolution */
-    private nameIndex;
     private config;
     constructor(config: RelationshipManagerConfig);
-    /** Normalize a name for fuzzy matching: lowercase, trim, collapse whitespace, strip leading @ */
-    private normalizeName;
-    /** Add a record to the name index */
-    private indexName;
-    /** Remove a record from the name index */
-    private unindexName;
     /** Validate a record ID is a valid UUID format to prevent path traversal. */
     private validateId;
     /**
@@ -34,47 +26,10 @@ export declare class RelationshipManager {
      * this returns the same relationship.
      */
     findOrCreate(name: string, channel: UserChannel): RelationshipRecord;
-    /**
-     * LLM-supervised version of findOrCreate.
-     * When an intelligence provider is configured:
-     * - Heuristics narrow candidates (channel match, name match)
-     * - LLM confirms ambiguous name matches before linking
-     * - LLM can detect matches that string heuristics miss
-     *
-     * Falls back to sync findOrCreate when no provider is available.
-     */
-    findOrCreateAsync(name: string, channel: UserChannel): Promise<RelationshipRecord>;
-    /**
-     * LLM-supervised duplicate detection.
-     * Runs heuristic findDuplicates() first, then asks the LLM to confirm
-     * each candidate group. Returns only LLM-confirmed duplicates.
-     *
-     * Falls back to heuristic-only when no provider is available.
-     */
-    findDuplicatesAsync(): Promise<Array<{
-        records: RelationshipRecord[];
-        reason: string;
-        confirmed: boolean;
-    }>>;
-    /**
-     * Ask the LLM whether a new name+channel belongs to one of the candidate records.
-     * Returns the matching record, or null if the LLM says it's a new person.
-     */
-    private askIdentityMatch;
-    /**
-     * Ask the LLM to confirm whether a group of records are truly duplicates.
-     */
-    private askDuplicateConfirmation;
     /**
      * Resolve a channel identifier to an existing relationship, or null.
      */
     resolveByChannel(channel: UserChannel): RelationshipRecord | null;
-    /**
-     * Resolve by name using fuzzy matching. Returns all matches.
-     * Handles: case differences, leading @, underscores vs hyphens vs spaces.
-     * Port of Portal's _find_existing_person() pattern.
-     */
-    resolveByName(name: string): RelationshipRecord[];
     /**
      * Get a relationship by ID.
      */
@@ -83,16 +38,6 @@ export declare class RelationshipManager {
      * Get all relationships, optionally sorted by significance or recency.
      */
     getAll(sortBy?: 'significance' | 'recent' | 'name'): RelationshipRecord[];
-    /**
-     * Detect potential duplicate relationships that could be merged.
-     * Port of Portal's find_potential_duplicates() pattern.
-     * Returns groups of records that likely represent the same person,
-     * with a reason string explaining why they were flagged.
-     */
-    findDuplicates(): Array<{
-        records: RelationshipRecord[];
-        reason: string;
-    }>;
     /**
      * Record an interaction with a person. Updates recency, count, and interaction log.
      */
@@ -117,18 +62,6 @@ export declare class RelationshipManager {
      * Delete a relationship and its disk file.
      */
     delete(id: string): boolean;
-    /**
-     * Update the category for a relationship.
-     */
-    updateCategory(id: string, category: string): void;
-    /**
-     * Add tags to a relationship (deduplicates).
-     */
-    addTags(id: string, tags: string[]): void;
-    /**
-     * Remove tags from a relationship.
-     */
-    removeTags(id: string, tags: string[]): void;
     /**
      * Generate context string for injection into a Claude session before interacting
      * with a known person. This is what makes the agent "know" who it's talking to.

package/dist/core/RelationshipManager.js

@@ -22,8 +22,6 @@ export class RelationshipManager {
     relationships = new Map();
     /** Maps "channel_type:identifier" -> relationship ID for cross-platform resolution */
     channelIndex = new Map();
-    /** Maps normalized name -> set of relationship IDs for fuzzy name resolution */
-    nameIndex = new Map();
     config;
     constructor(config) {
         this.config = config;
@@ -32,32 +30,6 @@ export class RelationshipManager {
         }
         this.loadAll();
     }
-    /** Normalize a name for fuzzy matching: lowercase, trim, collapse whitespace, strip leading @ */
-    normalizeName(name) {
-        return name.trim().toLowerCase().replace(/^@/, '').replace(/[\s_-]+/g, ' ');
-    }
-    /** Add a record to the name index */
-    indexName(id, name) {
-        const key = this.normalizeName(name);
-        if (!key)
-            return;
-        let ids = this.nameIndex.get(key);
-        if (!ids) {
-            ids = new Set();
-            this.nameIndex.set(key, ids);
-        }
-        ids.add(id);
-    }
-    /** Remove a record from the name index */
-    unindexName(id, name) {
-        const key = this.normalizeName(name);
-        const ids = this.nameIndex.get(key);
-        if (ids) {
-            ids.delete(id);
-            if (ids.size === 0)
-                this.nameIndex.delete(key);
-        }
-    }
     /** Validate a record ID is a valid UUID format to prevent path traversal. */
     validateId(id) {
         if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
@@ -72,80 +44,16 @@ export class RelationshipManager {
      */
     findOrCreate(name, channel) {
         const channelKey = `${channel.type}:${channel.identifier}`;
-        // Try to resolve by channel first (strongest signal)
-        const existingId = this.channelIndex.get(channelKey);
-        if (existingId) {
-            const existing = this.relationships.get(existingId);
-            if (existing)
-                return existing;
-            // Channel index is stale — clean it up and fall through
-            this.channelIndex.delete(channelKey);
-        }
-        // Try name resolution before creating (prevents ColonistOne-style duplicates)
-        const nameMatches = this.resolveByName(name);
-        if (nameMatches.length === 1) {
-            // Unambiguous name match — link the new channel and return
-            const match = nameMatches[0];
-            this.linkChannel(match.id, channel);
-            return match;
-        }
-        // Create new relationship (no match, or ambiguous name)
-        const now = new Date().toISOString();
-        const record = {
-            id: randomUUID(),
-            name,
-            channels: [channel],
-            firstInteraction: now,
-            lastInteraction: now,
-            interactionCount: 0,
-            themes: [],
-            notes: '',
-            significance: 1,
-            recentInteractions: [],
-        };
-        this.relationships.set(record.id, record);
-        this.channelIndex.set(channelKey, record.id);
-        this.indexName(record.id, name);
-        this.save(record);
-        return record;
-    }
-    /**
-     * LLM-supervised version of findOrCreate.
-     * When an intelligence provider is configured:
-     * - Heuristics narrow candidates (channel match, name match)
-     * - LLM confirms ambiguous name matches before linking
-     * - LLM can detect matches that string heuristics miss
-     *
-     * Falls back to sync findOrCreate when no provider is available.
-     */
-    async findOrCreateAsync(name, channel) {
-        const intelligence = this.config.intelligence;
-        // Channel match is always definitive — no LLM needed
-        const channelKey = `${channel.type}:${channel.identifier}`;
+        // Try to resolve by channel first
         const existingId = this.channelIndex.get(channelKey);
         if (existingId) {
             const existing = this.relationships.get(existingId);
             if (existing)
                 return existing;
+            // Channel index is stale — clean it up and fall through to create
             this.channelIndex.delete(channelKey);
         }
-        // Name-based candidates (heuristic pre-filter)
-        const nameMatches = this.resolveByName(name);
-        if (nameMatches.length === 1 && !intelligence) {
-            // No LLM, unambiguous match — link directly (sync behavior)
-            const match = nameMatches[0];
-            this.linkChannel(match.id, channel);
-            return match;
-        }
-        if (nameMatches.length >= 1 && intelligence) {
-            // LLM confirms: is this new interaction from one of the existing people?
-            const confirmed = await this.askIdentityMatch(intelligence, name, channel, nameMatches);
-            if (confirmed) {
-                this.linkChannel(confirmed.id, channel);
-                return confirmed;
-            }
-        }
-        // Create new (no match, or LLM said no match)
+        // Create new relationship
         const now = new Date().toISOString();
         const record = {
             id: randomUUID(),
@@ -161,110 +69,9 @@ export class RelationshipManager {
         };
         this.relationships.set(record.id, record);
         this.channelIndex.set(channelKey, record.id);
-        this.indexName(record.id, name);
         this.save(record);
         return record;
     }
-    /**
-     * LLM-supervised duplicate detection.
-     * Runs heuristic findDuplicates() first, then asks the LLM to confirm
-     * each candidate group. Returns only LLM-confirmed duplicates.
-     *
-     * Falls back to heuristic-only when no provider is available.
-     */
-    async findDuplicatesAsync() {
-        const candidates = this.findDuplicates();
-        const intelligence = this.config.intelligence;
-        if (!intelligence) {
-            return candidates.map((g) => ({ ...g, confirmed: false }));
-        }
-        const results = [];
-        for (const group of candidates) {
-            const confirmed = await this.askDuplicateConfirmation(intelligence, group.records, group.reason);
-            results.push({ ...group, confirmed });
-        }
-        return results;
-    }
-    // ── LLM Intelligence Prompts ────────────────────────────────────────
-    /**
-     * Ask the LLM whether a new name+channel belongs to one of the candidate records.
-     * Returns the matching record, or null if the LLM says it's a new person.
-     */
-    async askIdentityMatch(intelligence, name, channel, candidates) {
-        const candidateDescriptions = candidates.map((r, i) => {
-            const channels = r.channels.map((c) => `${c.type}:${c.identifier}`).join(', ');
-            const themes = r.themes.slice(0, 5).join(', ') || 'none';
-            return `[${i}] "${r.name}" — channels: ${channels} — themes: ${themes} — interactions: ${r.interactionCount}`;
-        }).join('\n');
-        const prompt = `You are an identity resolution system. Determine if a new interaction belongs to an existing person.
-
-New interaction:
-- Name: "${name}"
-- Channel: ${channel.type}:${channel.identifier}
-
-Existing candidates:
-${candidateDescriptions}
-
-Does the new interaction belong to one of these existing people? Consider:
-- Name similarity (case, spacing, special characters, abbreviations)
-- Platform conventions (same person may use different handles across platforms)
-- When uncertain, prefer creating a new record over a false merge
-
-Respond with ONLY one of:
-- MATCH:N (where N is the candidate index, e.g., MATCH:0)
-- NEW (if this is a different person)`;
-        try {
-            const response = await intelligence.evaluate(prompt, { model: 'fast', maxTokens: 20, temperature: 0 });
-            const trimmed = response.trim().toUpperCase();
-            const matchResult = trimmed.match(/^MATCH:(\d+)/);
-            if (matchResult) {
-                const index = parseInt(matchResult[1], 10);
-                if (index >= 0 && index < candidates.length) {
-                    return candidates[index];
-                }
-            }
-            // LLM explicitly said NEW — respect the decision
-            if (trimmed.startsWith('NEW')) {
-                return null;
-            }
-        }
-        catch {
-            // LLM call failed — fall back to heuristic behavior
-        }
-        // Default to heuristic: single unambiguous match → link, else new
-        return candidates.length === 1 ? candidates[0] : null;
-    }
-    /**
-     * Ask the LLM to confirm whether a group of records are truly duplicates.
-     */
-    async askDuplicateConfirmation(intelligence, records, reason) {
-        const descriptions = records.map((r, i) => {
-            const channels = r.channels.map((c) => `${c.type}:${c.identifier}`).join(', ');
-            const themes = r.themes.slice(0, 5).join(', ') || 'none';
-            return `[${i}] "${r.name}" — channels: ${channels} — themes: ${themes} — notes: ${(r.notes || '').slice(0, 100)}`;
-        }).join('\n');
-        const prompt = `You are an identity resolution system. Determine if these relationship records represent the same person.
-
-Flagged reason: ${reason}
-
-Records:
-${descriptions}
-
-Are these the same person? Consider:
-- Same name with different formatting is likely the same person
-- Different names on different platforms could be the same person if context aligns
-- Different themes/topics alone don't mean different people
-- When uncertain, say NO to avoid false merges
-
-Respond with ONLY: YES or NO`;
-        try {
-            const response = await intelligence.evaluate(prompt, { model: 'fast', maxTokens: 10, temperature: 0 });
-            return response.trim().toUpperCase().startsWith('YES');
-        }
-        catch {
-            return false; // Fail safe: don't confirm on error
-        }
-    }
     /**
      * Resolve a channel identifier to an existing relationship, or null.
      */
@@ -273,45 +80,6 @@ Respond with ONLY: YES or NO`;
         const id = this.channelIndex.get(channelKey);
         return id ? this.relationships.get(id) ?? null : null;
     }
-    /**
-     * Resolve by name using fuzzy matching. Returns all matches.
-     * Handles: case differences, leading @, underscores vs hyphens vs spaces.
-     * Port of Portal's _find_existing_person() pattern.
-     */
-    resolveByName(name) {
-        const key = this.normalizeName(name);
-        if (!key)
-            return [];
-        const results = [];
-        const seen = new Set();
-        // Exact normalized match
-        const exactIds = this.nameIndex.get(key);
-        if (exactIds) {
-            for (const id of exactIds) {
-                const r = this.relationships.get(id);
-                if (r && !seen.has(id)) {
-                    results.push(r);
-                    seen.add(id);
-                }
-            }
-        }
-        // Collapsed match (remove all separators): catches "ColonistOne" vs "colonist one"
-        const collapsed = key.replace(/\s/g, '');
-        for (const [indexKey, ids] of this.nameIndex) {
-            if (indexKey.replace(/\s/g, '') === collapsed) {
-                for (const id of ids) {
-                    if (!seen.has(id)) {
-                        const r = this.relationships.get(id);
-                        if (r) {
-                            results.push(r);
-                            seen.add(id);
-                        }
-                    }
-                }
-            }
-        }
-        return results;
-    }
     /**
      * Get a relationship by ID.
      */
@@ -332,64 +100,6 @@ Respond with ONLY: YES or NO`;
                 return all.sort((a, b) => a.name.localeCompare(b.name));
         }
     }
-    /**
-     * Detect potential duplicate relationships that could be merged.
-     * Port of Portal's find_potential_duplicates() pattern.
-     * Returns groups of records that likely represent the same person,
-     * with a reason string explaining why they were flagged.
-     */
-    findDuplicates() {
-        const groups = [];
-        const seen = new Set();
-        // Check for name collisions (same normalized name, different records)
-        for (const [key, ids] of this.nameIndex) {
-            if (ids.size > 1) {
-                const records = Array.from(ids)
-                    .map((id) => this.relationships.get(id))
-                    .filter((r) => r != null);
-                if (records.length > 1) {
-                    const groupKey = Array.from(ids).sort().join(',');
-                    if (!seen.has(groupKey)) {
-                        seen.add(groupKey);
-                        groups.push({
-                            records,
-                            reason: `Same normalized name: "${key}"`,
-                        });
-                    }
-                }
-            }
-        }
-        // Check for collapsed-name collisions (e.g., "colonist one" vs "colonistone")
-        const collapsedMap = new Map();
-        for (const [key, ids] of this.nameIndex) {
-            const collapsed = key.replace(/\s/g, '');
-            let existing = collapsedMap.get(collapsed);
-            if (!existing) {
-                existing = new Set();
-                collapsedMap.set(collapsed, existing);
-            }
-            for (const id of ids)
-                existing.add(id);
-        }
-        for (const [collapsed, ids] of collapsedMap) {
-            if (ids.size > 1) {
-                const groupKey = Array.from(ids).sort().join(',');
-                if (!seen.has(groupKey)) {
-                    seen.add(groupKey);
-                    const records = Array.from(ids)
-                        .map((id) => this.relationships.get(id))
-                        .filter((r) => r != null);
-                    if (records.length > 1) {
-                        groups.push({
-                            records,
-                            reason: `Similar collapsed name: "${collapsed}"`,
-                        });
-                    }
-                }
-            }
-        }
-        return groups;
-    }
     // ── Enrichment ─────────────────────────────────────────────────────
     /**
      * Record an interaction with a person. Updates recency, count, and interaction log.
@@ -506,23 +216,9 @@ Respond with ONLY: YES or NO`;
                 ? `${keep.notes}\n\n[Merged from ${merge.name}]: ${merge.notes}`.slice(0, MAX_NOTES_LENGTH)
                 : merge.notes.slice(0, MAX_NOTES_LENGTH);
         }
-        // Merge category (keep existing, or take from merged)
-        if (!keep.category && merge.category) {
-            keep.category = merge.category;
-        }
-        // Merge tags
-        if (merge.tags) {
-            if (!keep.tags)
-                keep.tags = [];
-            for (const tag of merge.tags) {
-                if (!keep.tags.includes(tag))
-                    keep.tags.push(tag);
-            }
-        }
         keep.significance = this.calculateSignificance(keep);
         this.save(keep);
-        // Delete the merged record and clean up name index
-        this.unindexName(mergeId, merge.name);
+        // Delete the merged record
         this.relationships.delete(mergeId);
         this.deleteFile(mergeId);
     }
@@ -540,48 +236,10 @@ Respond with ONLY: YES or NO`;
                 this.channelIndex.delete(channelKey);
             }
         }
-        // Remove name index entry
-        this.unindexName(id, record.name);
         this.relationships.delete(id);
         this.deleteFile(id);
         return true;
     }
-    /**
-     * Update the category for a relationship.
-     */
-    updateCategory(id, category) {
-        const record = this.relationships.get(id);
-        if (!record)
-            return;
-        record.category = category;
-        this.save(record);
-    }
-    /**
-     * Add tags to a relationship (deduplicates).
-     */
-    addTags(id, tags) {
-        const record = this.relationships.get(id);
-        if (!record)
-            return;
-        if (!record.tags)
-            record.tags = [];
-        for (const tag of tags) {
-            if (!record.tags.includes(tag)) {
-                record.tags.push(tag);
-            }
-        }
-        this.save(record);
-    }
-    /**
-     * Remove tags from a relationship.
-     */
-    removeTags(id, tags) {
-        const record = this.relationships.get(id);
-        if (!record || !record.tags)
-            return;
-        record.tags = record.tags.filter((t) => !tags.includes(t));
-        this.save(record);
-    }
     // ── Context Generation ─────────────────────────────────────────────
     /**
      * Generate context string for injection into a Claude session before interacting
@@ -602,17 +260,6 @@ Respond with ONLY: YES or NO`;
             `Total interactions: ${record.interactionCount}`,
             `Significance: ${record.significance}/10`,
         ];
-        // Cross-platform presence summary
-        if (record.channels.length > 1) {
-            const platforms = [...new Set(record.channels.map((c) => c.type))];
-            lines.push(`Platforms: ${platforms.map(sanitize).join(', ')}`);
-        }
-        if (record.category) {
-            lines.push(`Category: ${sanitize(record.category)}`);
-        }
-        if (record.tags && record.tags.length > 0) {
-            lines.push(`Tags: ${record.tags.map(sanitize).join(', ')}`);
-        }
         if (record.themes.length > 0) {
             lines.push(`Key themes: ${record.themes.map(sanitize).join(', ')}`);
         }
@@ -659,7 +306,6 @@ Respond with ONLY: YES or NO`;
                 }
                 this.validateId(data.id);
                 this.relationships.set(data.id, data);
-                this.indexName(data.id, data.name);
                 for (const channel of (data.channels ?? [])) {
                     this.channelIndex.set(`${channel.type}:${channel.identifier}`, data.id);
                 }