@pellux/goodvibes-agent 0.1.108 → 0.1.109

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.109 - 2026-06-02
+
+- 4152420 Let Agent remember through local registry tool
+
 ## 0.1.108 - 2026-06-02
 
 - f6b278c Harden Agent install and briefing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.108",
+  "version": "0.1.109",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/memory-prompt.ts

@@ -0,0 +1,35 @@
+import type { MemoryRecord, MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+
+const DEFAULT_LIMIT = 10;
+export const MIN_PROMPT_MEMORY_CONFIDENCE = 50;
+
+export function isPromptActiveMemory(record: MemoryRecord): boolean {
+  return record.reviewState === 'reviewed' && record.confidence >= MIN_PROMPT_MEMORY_CONFIDENCE;
+}
+
+function sortMemoryForPrompt(left: MemoryRecord, right: MemoryRecord): number {
+  if (right.confidence !== left.confidence) return right.confidence - left.confidence;
+  return right.updatedAt - left.updatedAt;
+}
+
+function formatMemoryLine(record: MemoryRecord): string {
+  const tags = record.tags.length > 0 ? ` tags=${record.tags.join(',')}` : '';
+  const provenance = record.provenance.length > 0
+    ? ` source=${record.provenance.slice(0, 2).map((entry) => `${entry.kind}:${entry.ref}`).join(',')}`
+    : '';
+  return `- [${record.scope}/${record.cls} ${record.confidence}%${tags}${provenance}] ${record.summary}`;
+}
+
+export function buildReviewedMemoryPrompt(memoryRegistry: MemoryRegistry, limit = DEFAULT_LIMIT): string | null {
+  const records = memoryRegistry.getAll()
+    .filter(isPromptActiveMemory)
+    .sort(sortMemoryForPrompt)
+    .slice(0, Math.max(0, limit));
+
+  if (records.length === 0) return null;
+  return [
+    '## Reviewed GoodVibes Agent Memory',
+    'Use these local, reviewed, non-secret memory records to avoid asking repeat questions and to preserve durable user preferences, constraints, and operating facts.',
+    ...records.map(formatMemoryLine),
+  ].join('\n');
+}

package/src/input/agent-workspace-snapshot.ts

@@ -4,6 +4,7 @@ import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../agent/skill-registry.ts';
+import { isPromptActiveMemory } from '../agent/memory-prompt.ts';
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
 import { buildAgentWorkspaceSetupChecklist } from './agent-workspace-setup.ts';
@@ -174,15 +175,16 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const memorySnapshot = (() => {
     try {
       const memory = context.clients?.agentKnowledgeApi?.memory;
-      if (!memory) return { count: 0, reviewQueueCount: 0, items: [] };
+      if (!memory) return { count: 0, reviewQueueCount: 0, promptActiveCount: 0, items: [] };
       const records = [...memory.getAll()].sort((left, right) => right.updatedAt - left.updatedAt);
       return {
         count: records.length,
         reviewQueueCount: memory.reviewQueue(100).length,
+        promptActiveCount: records.filter(isPromptActiveMemory).length,
         items: records.map(summarizeMemoryItem),
       };
     } catch {
-      return { count: 0, reviewQueueCount: 0, items: [] };
+      return { count: 0, reviewQueueCount: 0, promptActiveCount: 0, items: [] };
     }
   })();
   const personaSnapshot = (() => {
@@ -323,6 +325,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     sessionMemoryCount,
     localMemoryCount: memorySnapshot.count,
     localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
+    localMemoryPromptActiveCount: memorySnapshot.promptActiveCount,
     localMemories: memorySnapshot.items,
     localRoutineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,

package/src/input/agent-workspace-types.ts

@@ -150,6 +150,7 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly sessionMemoryCount: number;
   readonly localMemoryCount: number;
   readonly localMemoryReviewQueueCount: number;
+  readonly localMemoryPromptActiveCount: number;
   readonly localMemories: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localRoutineCount: number;
   readonly enabledRoutineCount: number;

package/src/input/commands/brief-runtime.ts

@@ -96,7 +96,7 @@ export function formatAgentOperatorBriefing(ctx: CommandContext): string {
     '',
     'Readiness',
     `  setup: ${setupReady}/${snapshot.setupChecklist.length} ready; ${setupRecommended} recommended; ${setupBlocked} blocked`,
-    `  local memory: ${plural(snapshot.localMemoryCount, 'record')}; review queue ${snapshot.localMemoryReviewQueueCount}`,
+    `  local memory: ${plural(snapshot.localMemoryCount, 'record')}; prompt-active ${snapshot.localMemoryPromptActiveCount}; review queue ${snapshot.localMemoryReviewQueueCount}`,
     `  personas: ${plural(snapshot.localPersonaCount, 'persona')}; active ${snapshot.activePersonaName}`,
     `  skills: ${snapshot.enabledSkillCount}/${snapshot.localSkillCount} enabled; bundles ${snapshot.enabledSkillBundleCount}/${snapshot.localSkillBundleCount}; active ${snapshot.activeSkillCount}`,
     `  routines: ${snapshot.enabledRoutineCount}/${snapshot.localRoutineCount} enabled`,

package/src/renderer/agent-workspace.ts

@@ -303,7 +303,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
   } else if (category.id === 'memory') {
     base.push(
       { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
-      { text: `Agent memory: ${snapshot.localMemoryCount}; review queue: ${snapshot.localMemoryReviewQueueCount}`, fg: PALETTE.info },
+      { text: `Agent memory: ${snapshot.localMemoryCount}; prompt-active: ${snapshot.localMemoryPromptActiveCount}; review queue: ${snapshot.localMemoryReviewQueueCount}`, fg: PALETTE.info },
       { text: `Local routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
       { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}; bundles: ${snapshot.localSkillBundleCount}; active skills: ${snapshot.activeSkillCount}`, fg: PALETTE.info },
       { text: `Local personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },

package/src/runtime/bootstrap-core.ts

@@ -228,7 +228,7 @@ export async function initializeBootstrapCore(
     overflowHandler: services.overflowHandler,
     changeTracker: services.sessionChangeTracker,
   });
-  registerAgentLocalRegistryTool(toolRegistry, services.shellPaths);
+  registerAgentLocalRegistryTool(toolRegistry, services.shellPaths, services.memoryRegistry);
   installAgentToolPolicyGuard(toolRegistry, {
     getLastUserMessage: () => conversation.getLastUserMessage(),
   });

package/src/runtime/bootstrap.ts

@@ -43,12 +43,13 @@ import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { buildActivePersonaPrompt } from '../agent/persona-registry.ts';
 import { buildEnabledSkillsPrompt } from '../agent/skill-registry.ts';
 import { buildEnabledRoutinesPrompt } from '../agent/routine-registry.ts';
+import { buildReviewedMemoryPrompt } from '../agent/memory-prompt.ts';
 
 const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '## GoodVibes Agent Operator Policy',
   '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure local Agent state, use read-only connected-service/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
   '- GoodVibes Agent connects to GoodVibes services owned outside this package. Do not start, stop, restart, install, expose, or mutate connected-service network/listener posture from Agent.',
-  '- Use the `agent_local_registry` tool when a reusable persona, skill, or routine would improve future work. Keep those records local, non-secret, source/provenance tagged, and reviewable. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
+  '- Use the `agent_local_registry` tool when a durable memory, reusable persona, skill, skill bundle, or routine would improve future work. Keep those records local, non-secret, source/provenance tagged, and reviewable. Review memory with a confidence score when it should shape future turns. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
   '- WRFC is never the default Agent reasoning path. Do not create local WRFC chains for planning, research, operations, knowledge, memory, configuration, approvals, automation observability, or ordinary assistant work.',
   '- GoodVibes Agent is not the coding TUI. Do not use the `agent` tool to spawn local Engineer, Reviewer, Tester, Verifier, or batch-spawn roots from Agent.',
   '- When the user explicitly asks to build, implement, fix, patch, or review code, preserve the full original user ask and delegate one build request to GoodVibes TUI through the public shared-session/build-delegation contract. Include clear executionIntent and request WRFC only for explicit build/fix/review work or when the user explicitly asks for WRFC/agent review.',
@@ -206,6 +207,7 @@ export async function bootstrapRuntime(
       return joinPromptParts(
         runtime.systemPrompt,
         GOODVIBES_AGENT_OPERATOR_POLICY,
+        buildReviewedMemoryPrompt(services.memoryRegistry),
         buildEnabledRoutinesPrompt(services.shellPaths),
         buildEnabledSkillsPrompt(services.shellPaths),
         buildActivePersonaPrompt(services.shellPaths),

package/src/tools/agent-local-registry-tool.ts

@@ -1,11 +1,18 @@
 import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { ShellPathService } from '@/runtime/index.ts';
+import {
+  MemoryRegistry,
+  type MemoryClass,
+  type MemoryRecord,
+  type MemoryScope,
+} from '@pellux/goodvibes-sdk/platform/state';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
-import { AgentSkillRegistry, type AgentSkillRecord } from '../agent/skill-registry.ts';
+import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../agent/skill-registry.ts';
+import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
 
-export type AgentLocalRegistryDomain = 'persona' | 'skill' | 'routine';
+export type AgentLocalRegistryDomain = 'memory' | 'persona' | 'skill' | 'skill_bundle' | 'routine';
 export type AgentLocalRegistryAction =
   | 'list'
   | 'search'
@@ -25,11 +32,18 @@ export interface AgentLocalRegistryToolArgs {
   readonly action?: unknown;
   readonly id?: unknown;
   readonly query?: unknown;
+  readonly cls?: unknown;
+  readonly scope?: unknown;
+  readonly summary?: unknown;
+  readonly detail?: unknown;
+  readonly confidence?: unknown;
   readonly name?: unknown;
   readonly description?: unknown;
   readonly body?: unknown;
   readonly procedure?: unknown;
   readonly steps?: unknown;
+  readonly skills?: unknown;
+  readonly skillIds?: unknown;
   readonly triggers?: unknown;
   readonly tags?: unknown;
   readonly reason?: unknown;
@@ -37,7 +51,7 @@ export interface AgentLocalRegistryToolArgs {
   readonly provenance?: unknown;
 }
 
-const DOMAINS: readonly AgentLocalRegistryDomain[] = ['persona', 'skill', 'routine'];
+const DOMAINS: readonly AgentLocalRegistryDomain[] = ['memory', 'persona', 'skill', 'skill_bundle', 'routine'];
 const ACTIONS: readonly AgentLocalRegistryAction[] = [
   'list',
   'search',
@@ -52,6 +66,8 @@ const ACTIONS: readonly AgentLocalRegistryAction[] = [
   'clear_active',
   'start',
 ];
+const MEMORY_CLASSES: readonly MemoryClass[] = ['decision', 'constraint', 'incident', 'pattern', 'fact', 'risk', 'runbook', 'architecture', 'ownership'];
+const MEMORY_SCOPES: readonly MemoryScope[] = ['session', 'project', 'team'];
 
 function isDomain(value: unknown): value is AgentLocalRegistryDomain {
   return typeof value === 'string' && DOMAINS.includes(value as AgentLocalRegistryDomain);
@@ -73,6 +89,28 @@ function readStringList(value: unknown): readonly string[] {
   return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function readOptionalNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'string' || !value.trim()) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function readOptionalConfidence(value: unknown): number | undefined {
+  const confidence = readOptionalNumber(value);
+  if (confidence === undefined) return undefined;
+  if (confidence < 0 || confidence > 100) throw new Error('confidence must be between 0 and 100.');
+  return confidence;
+}
+
+function isMemoryClass(value: unknown): value is MemoryClass {
+  return typeof value === 'string' && MEMORY_CLASSES.includes(value as MemoryClass);
+}
+
+function isMemoryScope(value: unknown): value is MemoryScope {
+  return typeof value === 'string' && MEMORY_SCOPES.includes(value as MemoryScope);
+}
+
 function registryError(message: string): { readonly success: false; readonly error: string } {
   return { success: false, error: message };
 }
@@ -99,6 +137,104 @@ function requireDescription(args: AgentLocalRegistryToolArgs): string {
   return description;
 }
 
+function requireSummary(args: AgentLocalRegistryToolArgs): string {
+  const summary = readString(args.summary || args.description);
+  if (!summary) throw new Error('summary is required.');
+  return summary;
+}
+
+function requireMemoryClass(args: AgentLocalRegistryToolArgs): MemoryClass {
+  const cls = args.cls || 'fact';
+  if (!isMemoryClass(cls)) throw new Error(`Invalid memory class. Valid: ${MEMORY_CLASSES.join(', ')}.`);
+  return cls;
+}
+
+function readMemoryScope(args: AgentLocalRegistryToolArgs): MemoryScope {
+  const scope = args.scope || 'project';
+  if (!isMemoryScope(scope)) throw new Error(`Invalid memory scope. Valid: ${MEMORY_SCOPES.join(', ')}.`);
+  return scope;
+}
+
+function formatMemory(record: MemoryRecord): string {
+  const tags = record.tags.length > 0 ? ` tags=${record.tags.join(',')}` : '';
+  return `${record.id}  ${record.scope}/${record.cls}  ${record.reviewState}  ${record.confidence}%${tags}  ${record.summary}`;
+}
+
+async function handleMemory(registry: MemoryRegistry, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): Promise<string> {
+    if (action === 'list') {
+      const records = registry.getAll();
+      return records.length === 0
+        ? 'Agent-local memory\nNo Agent-local memory records.'
+        : ['Agent-local memory', ...records.map(formatMemory)].join('\n');
+    }
+    if (action === 'search') {
+      const query = readString(args.query);
+      const records = registry.search({ query, limit: 10 });
+      return records.length === 0
+        ? `Agent-local memory search\nNo Agent-local memory records matched "${query}".`
+        : [`Agent-local memory search: ${query || '(all)'}`, ...records.map(formatMemory)].join('\n');
+    }
+    if (action === 'get') {
+      const record = registry.get(requireId(args));
+      if (!record) return `Unknown Agent-local memory: ${readString(args.id)}`;
+      return [
+        formatMemory(record),
+        `created: ${new Date(record.createdAt).toISOString()}`,
+        `updated: ${new Date(record.updatedAt).toISOString()}`,
+        `provenance: ${record.provenance.map((entry) => `${entry.kind}:${entry.ref}`).join(', ') || '(none)'}`,
+        '',
+        record.detail || '(no detail)',
+      ].join('\n');
+    }
+    if (action === 'create') {
+      const summary = requireSummary(args);
+      const detail = readString(args.detail || args.body);
+      const tags = readStringList(args.tags);
+      assertNoSecretLikeMemoryText([summary, detail, ...tags]);
+      const record = await registry.add({
+        scope: readMemoryScope(args),
+        cls: requireMemoryClass(args),
+        summary,
+        detail,
+        tags: [...tags],
+        provenance: [{ kind: 'event', ref: readString(args.provenance) || 'agent-local-registry-tool' }],
+      });
+      return `Created Agent-local memory ${record.id}: ${record.summary}`;
+    }
+    if (action === 'update') {
+      const summary = readString(args.summary || args.description);
+      const detail = readString(args.detail || args.body);
+      const tags = args.tags === undefined ? undefined : [...readStringList(args.tags)];
+      assertNoSecretLikeMemoryText([summary, detail, ...(tags ?? [])]);
+      const record = registry.update(requireId(args), {
+        summary: summary || undefined,
+        detail: detail || undefined,
+        tags,
+        scope: args.scope === undefined ? undefined : readMemoryScope(args),
+      });
+      if (!record) return `Unknown Agent-local memory: ${readString(args.id)}`;
+      return `Updated Agent-local memory ${record.id}: ${record.summary}`;
+    }
+    if (action === 'review') {
+      const record = registry.review(requireId(args), {
+        state: 'reviewed',
+        confidence: readOptionalConfidence(args.confidence),
+        reviewedBy: 'agent',
+      });
+      if (!record) return `Unknown Agent-local memory: ${readString(args.id)}`;
+      return `Reviewed Agent-local memory ${record.id}.`;
+    }
+    if (action === 'stale') {
+      const record = registry.review(requireId(args), {
+        state: 'stale',
+        staleReason: readString(args.reason) || 'Marked stale by Agent.',
+      });
+      if (!record) return `Unknown Agent-local memory: ${readString(args.id)}`;
+      return `Marked Agent-local memory ${record.id} stale.`;
+    }
+    throw new Error(`Action ${action} is not valid for memory.`);
+}
+
 function formatPersona(persona: AgentPersonaRecord, activeId: string | null): string {
   const active = persona.id === activeId ? 'active' : 'inactive';
   return `${persona.id}  ${active}  ${persona.reviewState}  ${persona.name} - ${persona.description}`;
@@ -109,6 +245,11 @@ function formatSkill(skill: AgentSkillRecord): string {
   return `${skill.id}  ${enabled}  ${skill.reviewState}  ${skill.name} - ${skill.description}`;
 }
 
+function formatSkillBundle(bundle: AgentSkillBundleRecord): string {
+  const enabled = bundle.enabled ? 'enabled' : 'disabled';
+  return `${bundle.id}  ${enabled}  ${bundle.reviewState}  ${bundle.name} - ${bundle.description} skills=${bundle.skillIds.join(',')}`;
+}
+
 function formatRoutine(routine: AgentRoutineRecord): string {
   const enabled = routine.enabled ? 'enabled' : 'disabled';
   return `${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}`;
@@ -127,6 +268,12 @@ function listSkills(records: readonly AgentSkillRecord[], title: string): string
     : [title, ...records.map(formatSkill)].join('\n');
 }
 
+function listSkillBundles(records: readonly AgentSkillBundleRecord[], title: string): string {
+  return records.length === 0
+    ? `${title}\nNo Agent-local skill bundles.`
+    : [title, ...records.map(formatSkillBundle)].join('\n');
+}
+
 function listRoutines(records: readonly AgentRoutineRecord[], title: string): string {
   return records.length === 0
     ? `${title}\nNo Agent-local routines.`
@@ -232,6 +379,49 @@ function handleSkill(shellPaths: ShellPathService, action: AgentLocalRegistryAct
   throw new Error(`Action ${action} is not valid for skills.`);
 }
 
+function handleSkillBundle(shellPaths: ShellPathService, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): string {
+  const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+  if (action === 'list') return listSkillBundles(registry.listBundles(), 'Agent-local skill bundles');
+  if (action === 'search') return listSkillBundles(registry.searchBundles(readString(args.query)), 'Agent-local skill bundles search');
+  if (action === 'get') {
+    const bundle = registry.getBundle(requireId(args));
+    if (!bundle) return `Unknown Agent-local skill bundle: ${readString(args.id)}`;
+    return [
+      formatSkillBundle(bundle),
+      `skills: ${bundle.skillIds.join(', ')}`,
+      '',
+      bundle.description,
+    ].join('\n');
+  }
+  if (action === 'create') {
+    const bundle = registry.createBundle({
+      name: requireName(args),
+      description: requireDescription(args),
+      skillIds: readStringList(args.skillIds ?? args.skills),
+      enabled: args.enabled === true,
+      source: 'agent',
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Created Agent-local skill bundle ${bundle.id}: ${bundle.name}`;
+  }
+  if (action === 'update') {
+    const bundle = registry.updateBundle(requireId(args), {
+      name: readString(args.name) || undefined,
+      description: readString(args.description) || undefined,
+      skillIds: args.skillIds === undefined && args.skills === undefined ? undefined : readStringList(args.skillIds ?? args.skills),
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Updated Agent-local skill bundle ${bundle.id}: ${bundle.name}`;
+  }
+  if (action === 'enable' || action === 'disable') {
+    const bundle = registry.setBundleEnabled(requireId(args), action === 'enable');
+    return `${action === 'enable' ? 'Enabled' : 'Disabled'} Agent-local skill bundle ${bundle.id}: ${bundle.name}`;
+  }
+  if (action === 'review') return `Reviewed Agent-local skill bundle ${registry.markBundleReviewed(requireId(args)).id}.`;
+  if (action === 'stale') return `Marked Agent-local skill bundle ${registry.markBundleStale(requireId(args), readString(args.reason)).id} stale.`;
+  throw new Error(`Action ${action} is not valid for skill bundles.`);
+}
+
 function handleRoutine(shellPaths: ShellPathService, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): string {
   const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
   if (action === 'list') return listRoutines(registry.list(), 'Agent-local routines');
@@ -289,14 +479,14 @@ function handleRoutine(shellPaths: ShellPathService, action: AgentLocalRegistryA
   throw new Error(`Action ${action} is not valid for routines.`);
 }
 
-export function createAgentLocalRegistryTool(shellPaths: ShellPathService): Tool {
+export function createAgentLocalRegistryTool(shellPaths: ShellPathService, memoryRegistry: MemoryRegistry): Tool {
   return {
     definition: {
       name: 'agent_local_registry',
       description: [
-        'Inspect and maintain GoodVibes Agent-local personas, skills, and routines from the main conversation.',
-        'Use this for safe self-improvement: create or refine reusable behavior, enable skills/routines, choose personas, review/stale records, and start routines in the same serial conversation.',
-        'This tool cannot delete records, create schedules, mutate the daemon, send messages, run background jobs, or delegate build work.',
+        'Inspect and maintain GoodVibes Agent-local memory, personas, skills, and routines from the main conversation.',
+        'Use this for safe self-improvement: remember durable non-secret facts, create or refine reusable behavior, bundle related skills, enable skills/routines, choose personas, review/stale records, and start routines in the same serial conversation.',
+        'This tool cannot delete records, create schedules, mutate connected services, send messages, run background jobs, or delegate build work.',
       ].join(' '),
       parameters: {
         type: 'object',
@@ -305,11 +495,18 @@ export function createAgentLocalRegistryTool(shellPaths: ShellPathService): Tool
           action: { type: 'string', enum: [...ACTIONS] },
           id: { type: 'string' },
           query: { type: 'string' },
+          cls: { type: 'string', enum: [...MEMORY_CLASSES], description: 'Memory class when domain is memory.' },
+          scope: { type: 'string', enum: [...MEMORY_SCOPES], description: 'Memory scope when domain is memory.' },
+          summary: { type: 'string', description: 'Memory summary when domain is memory.' },
+          detail: { type: 'string', description: 'Memory detail when domain is memory.' },
+          confidence: { type: 'number', description: 'Memory review confidence from 0 to 100.' },
           name: { type: 'string' },
           description: { type: 'string' },
           body: { type: 'string', description: 'Persona body/instructions.' },
           procedure: { type: 'string', description: 'Skill procedure.' },
           steps: { type: 'string', description: 'Routine steps.' },
+          skills: { type: 'array', items: { type: 'string' }, description: 'Skill ids for skill_bundle create/update.' },
+          skillIds: { type: 'array', items: { type: 'string' }, description: 'Skill ids for skill_bundle create/update.' },
           triggers: { type: 'array', items: { type: 'string' } },
           tags: { type: 'array', items: { type: 'string' } },
           reason: { type: 'string' },
@@ -326,8 +523,10 @@ export function createAgentLocalRegistryTool(shellPaths: ShellPathService): Tool
       if (!isDomain(args.domain)) return registryError(`Unknown domain. Valid: ${DOMAINS.join(', ')}.`);
       if (!isAction(args.action)) return registryError(`Unknown action. Valid: ${ACTIONS.join(', ')}.`);
       try {
+        if (args.domain === 'memory') return registryOutput(await handleMemory(memoryRegistry, args.action, args));
         if (args.domain === 'persona') return registryOutput(handlePersona(shellPaths, args.action, args));
         if (args.domain === 'skill') return registryOutput(handleSkill(shellPaths, args.action, args));
+        if (args.domain === 'skill_bundle') return registryOutput(handleSkillBundle(shellPaths, args.action, args));
         return registryOutput(handleRoutine(shellPaths, args.action, args));
       } catch (error) {
         return registryError(error instanceof Error ? error.message : String(error));
@@ -336,6 +535,6 @@ export function createAgentLocalRegistryTool(shellPaths: ShellPathService): Tool
   };
 }
 
-export function registerAgentLocalRegistryTool(registry: ToolRegistry, shellPaths: ShellPathService): void {
-  registry.register(createAgentLocalRegistryTool(shellPaths));
+export function registerAgentLocalRegistryTool(registry: ToolRegistry, shellPaths: ShellPathService, memoryRegistry: MemoryRegistry): void {
+  registry.register(createAgentLocalRegistryTool(shellPaths, memoryRegistry));
 }

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.108';
+let _version = '0.1.109';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {