@pellux/goodvibes-agent 0.1.107 → 0.1.109

package/src/renderer/settings-modal.ts

@@ -31,26 +31,26 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
   storage: 'Local storage posture, including secret storage policy and maximum artifact size for Agent Knowledge, artifacts, and document ingestion.',
   permissions: 'Permission mode and tool-class policy. These settings decide whether the shell prompts before read/write/exec/network/agent actions.',
   orchestration: 'Agent orchestration limits and recursion controls.',
-  wrfc: 'WRFC is external to normal Agent operation. Review these runtime compatibility values only for explicit GoodVibes TUI build delegation.',
+  wrfc: 'WRFC is external to normal Agent operation. Review these compatibility values only for explicit GoodVibes TUI build delegation.',
   helper: 'Helper model defaults used by helper subsystems when they do not use the main chat route.',
   tts: 'Text-to-speech provider, voice, and optional spoken-turn LLM overrides.',
-  service: 'External runtime installation posture. Agent shows these compatibility keys for inspection only and does not install, start, stop, restart, or autostart anything.',
-  controlPlane: 'External runtime API connection settings. Agent connects to that runtime and does not mutate its bind posture.',
-  httpListener: 'Inbound event endpoint settings owned by the external runtime. Agent inspects readiness and does not expose endpoints.',
+  service: 'Connected-service installation posture. Agent shows these compatibility keys for inspection only and does not install, start, stop, restart, or autostart anything.',
+  controlPlane: 'Connected-service API settings. Agent uses these settings for access and does not mutate bind posture.',
+  httpListener: 'Inbound event endpoint settings owned by connected GoodVibes services. Agent inspects readiness and does not expose endpoints.',
   web: 'External browser companion settings. Agent does not own browser hosting or network bind lifecycle.',
-  batch: 'Batch execution settings reported from the external GoodVibes runtime. Agent does not own remote queue provisioning.',
+  batch: 'Batch execution settings reported from connected GoodVibes services. Agent does not own remote queue provisioning.',
   automation: 'Scheduled and automated run settings, concurrency, timeout, catch-up, cooldown, and retention behavior.',
   watchers: 'File/process watcher heartbeat, polling, and recovery-window behavior.',
-  runtime: 'Runtime guardrails such as companion chat limiter and event bus listener caps.',
+  runtime: 'Connected-service guardrails such as companion chat limiter and event bus listener caps.',
   telemetry: 'Telemetry payload policy.',
   cache: 'Provider and model cache behavior, TTL, and hit-rate monitoring.',
   mcp: 'MCP server trust and scope review. Trust changes can expose local files, tools, databases, browsers, or remote automation depending on the server.',
   surfaces: 'Messaging and notification channel accounts such as Slack, Discord, ntfy, Telegram, chat bridges, and delivery providers.',
   release: 'Release-channel preference.',
-  danger: 'High-impact runtime switches. Agent renders host-owned switches read-only; use the owning GoodVibes runtime host to change them.',
+  danger: 'High-impact service switches. Agent renders service-owned switches read-only; change them outside Agent.',
   tools: 'Tool LLM and helper model routing. Empty provider/model values inherit the active chat route unless a specific helper/tool route is set.',
-  flags: 'Feature flags are SDK runtime gates. They are separate from normal config keys because they enable or disable staged runtime behavior.',
-  network: 'Read-only view of external runtime API, inbound-event, and browser companion bind posture plus editable Agent network settings.',
+  flags: 'Feature flags are SDK gates. They are separate from normal config keys because they enable or disable staged behavior.',
+  network: 'Read-only view of connected GoodVibes API, inbound-event, and browser companion bind posture plus editable Agent network settings.',
 };
 
 const ENUM_VALUE_DESCRIPTIONS: Record<string, Record<string, string>> = {
@@ -148,7 +148,7 @@ function buildSettingContext(modal: SettingsModal, entry: SettingEntry): string[
   ];
 
   if (entry.locked) lines.push(`Locked: ${entry.lockReason ?? 'This setting is locked by a higher-priority layer.'}`);
-  if (entry.conflict) lines.push(`Conflict: inspect with /settings and resolve runtime-owned sync state in the external host.`);
+  if (entry.conflict) lines.push(`Conflict: inspect with /settings and resolve service-owned sync state in the owning host.`);
 
   lines.push('', entry.setting.description);
 
@@ -202,7 +202,7 @@ function buildFlagContext(entry: FlagEntry | null): string[] {
     `State: ${entry.state}`,
     `Default: ${entry.flag.defaultState}`,
     `Tier: ${entry.flag.tier}`,
-    `Runtime toggleable: ${entry.flag.runtimeToggleable ? 'yes' : 'no'}`,
+    `Live toggleable: ${entry.flag.runtimeToggleable ? 'yes' : 'no'}`,
     '',
     entry.flag.description,
     ...(entry.state === 'killed' && entry.flag.killReason ? ['', `Kill reason: ${entry.flag.killReason}`] : []),
@@ -479,7 +479,7 @@ function footerText(modal: SettingsModal): string {
   if (modal.currentCategory === 'flags') return 'Focus feature flags · Up/Down flag · Left categories · Tab pane · Enter/Space toggle · Esc close';
   const selected = modal.getSelected();
   if (selected && isExternalDaemonOwnedSettingKey(selected.setting.key)) {
-    return 'Read-only external runtime setting · Change from GoodVibes TUI or the owning host · Esc close';
+    return 'Read-only connected-service setting · Change from GoodVibes TUI or the owning host · Esc close';
   }
   return 'Focus settings · Up/Down setting · Left categories · Tab pane · Enter/Space edit/toggle · R reset · Esc close';
 }
@@ -490,7 +490,7 @@ export function renderSettingsModal(
   viewportHeight = 24,
 ): Line[] {
   const notices = [
-    ...(modal.lastSaveTriggeredRestart ? [`External runtime owner must restart ${modal.lastSaveTriggeredRestart}`] : []),
+    ...(modal.lastSaveTriggeredRestart ? [`Owning host must restart ${modal.lastSaveTriggeredRestart}`] : []),
     ...(modal.lastSettingEffectMessage ? [modal.lastSettingEffectMessage] : []),
   ];
   const metrics = getFullscreenWorkspaceMetrics({ width, height: viewportHeight });

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-hook-bridge.ts

@@ -74,7 +74,7 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
           options.conversation.log(`Resume: Reopened panels: ${reopenedPanels.join(', ')}`, { fg: '244' });
         }
         if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
-          options.conversation.log('Resume: Remote re-entry belongs to the external runtime host; delegate explicit build/fix/review recovery from Agent.', { fg: '244' });
+          options.conversation.log('Resume: Remote runner recovery belongs outside Agent; delegate explicit build/fix/review recovery from Agent.', { fg: '244' });
         }
         if (returnContextMode === 'assisted') {
           const helperModel = new HelperModel({

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 runtime/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
-  '- GoodVibes Agent connects to an externally managed GoodVibes runtime host. Do not start, stop, restart, install, expose, or mutate runtime-host network/listener posture from Agent runtime.',
-  '- 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.',
+  '- 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 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),
@@ -332,8 +334,8 @@ export async function bootstrapRuntime(
       port,
       baseUrl: formatHostServiceBaseUrl(host, port),
       reason: service === 'daemon'
-        ? 'GoodVibes Agent connects to an externally managed GoodVibes runtime host and does not start or restart it.'
-        : 'GoodVibes Agent does not own external listener lifecycle.',
+        ? 'GoodVibes Agent connects to GoodVibes services owned outside this product and does not start or restart them.'
+        : 'GoodVibes Agent does not own listener lifecycle.',
     };
   };
 
@@ -373,7 +375,7 @@ export async function bootstrapRuntime(
         daemonStatus: createExternalAgentServiceStatus('daemon'),
         httpListenerStatus: createExternalAgentServiceStatus('httpListener'),
       };
-      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart runtime-host services. Start the GoodVibes runtime from its owner, then refresh status.');
+      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart connected GoodVibes services. Start them from GoodVibes TUI or the owning host, then refresh status.');
       requestRender();
       return inspectExternalServices();
     },
@@ -450,8 +452,8 @@ export async function bootstrapRuntime(
   });
   bootstrapUnsubs.push(() => mcpAutoReload.stop());
   if (configManager.get('automation.enabled')) {
-    logger.warn('Local automation startup is disabled in GoodVibes Agent; use external runtime observability instead.');
-    systemMessageRouter.low('[Startup] Local automation runners are disabled in GoodVibes Agent; use read-only automation observability or explicit external-runtime actions.');
+    logger.warn('Local automation startup is disabled in GoodVibes Agent; use connected-service observability instead.');
+    systemMessageRouter.low('[Startup] Local automation runners are disabled in GoodVibes Agent; use read-only automation observability or explicit connected-service actions.');
   }
 
   // ── Phase 12: Session:start lifecycle hook ─────────────────────────────
@@ -553,7 +555,7 @@ export async function bootstrapRuntime(
   };
 
   // ── Phase 12b: Operator intervention wiring (feature-gated) ──────────────
-  // Keep runtime-owned control-plane state internal. GoodVibes Agent does not
+  // Keep service-owned control-plane state internal. GoodVibes Agent does not
   // expose the local ops-control panel; operator control is surfaced
   // through Agent-owned status, approvals, automation, and delegation flows.
   ctx.commandContext.ops.acpManager = acpManager;

package/src/runtime/index.ts

@@ -113,8 +113,8 @@ function agentExternalHostStatus(
     port,
     baseUrl: `http://${host}:${port}`,
     reason: service === 'daemon'
-      ? 'GoodVibes Agent connects to an externally managed GoodVibes runtime host and does not start or restart it.'
-      : 'GoodVibes Agent does not own external listener lifecycle.',
+      ? 'GoodVibes Agent connects to GoodVibes services owned outside this product and does not start or restart them.'
+      : 'GoodVibes Agent does not own listener lifecycle.',
   };
 }
 

package/src/runtime/onboarding/derivation.ts

@@ -264,10 +264,10 @@ function hasAutomationReviewSignals(snapshot: OnboardingSnapshotState): boolean
 
 function describeOperatorTerminal(snapshot: OnboardingSnapshotState): string {
   if (!hasAnyServerEnabled(snapshot)) {
-    return 'Use GoodVibes Agent as the terminal operator while connecting to the existing GoodVibes runtime. Agent setup does not create new entrypoints.';
+    return 'Use GoodVibes Agent as the terminal operator while connecting to existing GoodVibes services. Agent setup does not create new entrypoints.';
   }
 
-  return 'Use GoodVibes Agent as the terminal operator; runtime host settings are shown only so the connection is understandable.';
+  return 'Use GoodVibes Agent as the terminal operator; connection settings are shown only so setup is understandable.';
 }
 
 function describeProviderAccess(snapshot: OnboardingSnapshotState): string {
@@ -500,23 +500,23 @@ export function deriveReopenEditAcknowledgementState(
         snapshot,
         'auth',
         'bootstrap-credential',
-        'An external runtime bootstrap credential signal is still visible to Agent.',
+        'A connected-service bootstrap credential signal is still visible to Agent.',
       )
     : authSessionCount > 0
       ? buildRequiredAcknowledgement(
           snapshot,
           'auth',
           'active-sessions',
-          `${authSessionCount} external runtime auth session signal(s) are currently visible.`,
+          `${authSessionCount} connected-service auth session signal(s) are currently visible.`,
         )
       : authUserCount > 0
         ? buildRequiredAcknowledgement(
             snapshot,
             'auth',
             'auth-state',
-            `${authUserCount} external runtime auth user signal(s) are already visible.`,
+            `${authUserCount} connected-service auth user signal(s) are already visible.`,
           )
-        : buildNotNeededAcknowledgement(snapshot, 'auth', 'No external runtime auth signal needs confirmation.');
+        : buildNotNeededAcknowledgement(snapshot, 'auth', 'No connected-service auth signal needs confirmation.');
 
   return {
     providers,

package/src/shell/service-settings-sync.ts

@@ -1,7 +1,7 @@
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import type { CliServiceRuntime } from '../cli/service-posture.ts';
 
-export const AGENT_EXTERNAL_DAEMON_SERVICE_MESSAGE = 'GoodVibes Agent connects to an external daemon and does not install, start, stop, restart, or uninstall daemon services. Manage daemon lifecycle from GoodVibes TUI or your daemon host tooling.';
+export const AGENT_EXTERNAL_DAEMON_SERVICE_MESSAGE = 'GoodVibes Agent uses connected GoodVibes services and does not install, start, stop, restart, or uninstall them. Manage service lifecycle outside Agent.';
 
 export interface ServiceSettingsSyncChange {
   readonly key: ConfigKey;

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.107';
+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 {