@pellux/goodvibes-agent 0.1.48 → 0.1.50

package/CHANGELOG.md

@@ -2,10 +2,20 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.50 - 2026-05-31
+
+- bdb654a Improve local library workspaces
+
+## 0.1.49 - 2026-05-31
+
+- 445e694 Show isolated Agent Knowledge in TUI panel
+- 632d951 Add agent-local registry tool
+- 4832355 Make agent setup workspace actionable
+
 ## 0.1.48 - 2026-05-31
 
 - 67f8ce0 Remove audit remnants and surface setup checklist
-- 34c3d0b Remove internal capability audit surfaces
+- 34c3d0b Remove internal development-only surfaces
 
 ## 0.1.47 - 2026-05-31
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "private": false,
   "description": "Near-fork GoodVibes operator assistant with the GoodVibes TUI shell, renderer, input, fullscreen workspace, and daemon-connected Agent product brain.",
   "type": "module",

package/src/input/agent-workspace.ts

@@ -1,9 +1,9 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import { basename, sep } from 'node:path';
 import type { CommandContext } from './command-registry.ts';
-import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
-import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
-import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+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 { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import {
   buildAgentWorkspaceChannels,
@@ -20,13 +20,14 @@ export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
 export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 
-export type AgentWorkspaceActionKind = 'command' | 'guidance';
+export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace';
 
 export interface AgentWorkspaceAction {
   readonly id: string;
   readonly label: string;
   readonly detail: string;
   readonly command?: string;
+  readonly targetCategoryId?: string;
   readonly kind: AgentWorkspaceActionKind;
   readonly safety: 'safe' | 'read-only' | 'delegates' | 'blocked';
 }
@@ -52,6 +53,19 @@ export interface AgentWorkspaceActionResult {
   readonly safety?: AgentWorkspaceAction['safety'];
 }
 
+export interface AgentWorkspaceLocalLibraryItem {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly reviewState: string;
+  readonly source: string;
+  readonly tags: readonly string[];
+  readonly triggers: readonly string[];
+  readonly active?: boolean;
+  readonly enabled?: boolean;
+  readonly startCount?: number;
+}
+
 type AgentWorkspaceConfigReader = {
   get(key: string): unknown;
 };
@@ -68,10 +82,13 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly sessionMemoryCount: number;
   readonly localRoutineCount: number;
   readonly enabledRoutineCount: number;
+  readonly localRoutines: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localSkillCount: number;
   readonly enabledSkillCount: number;
+  readonly localSkills: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localPersonaCount: number;
   readonly activePersonaName: string;
+  readonly localPersonas: readonly AgentWorkspaceLocalLibraryItem[];
   readonly knowledgeRoute: '/api/goodvibes-agent/knowledge';
   readonly knowledgeIsolation: 'agent-only';
   readonly executionPolicy: 'serial-proactive';
@@ -142,6 +159,46 @@ function inferActiveRuntimeProfile(homeDirectory: string): string {
   return homeDirectory.includes(marker) ? basename(homeDirectory) : '(default home)';
 }
 
+function summarizePersonaItem(persona: AgentPersonaRecord, activePersonaId: string | null): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: persona.id,
+    name: persona.name,
+    description: persona.description,
+    reviewState: persona.reviewState,
+    source: persona.source,
+    tags: persona.tags,
+    triggers: persona.triggers,
+    active: persona.id === activePersonaId,
+  };
+}
+
+function summarizeSkillItem(skill: AgentSkillRecord): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    reviewState: skill.reviewState,
+    source: skill.source,
+    tags: skill.tags,
+    triggers: skill.triggers,
+    enabled: skill.enabled,
+  };
+}
+
+function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: routine.id,
+    name: routine.name,
+    description: routine.description,
+    reviewState: routine.reviewState,
+    source: routine.source,
+    tags: routine.tags,
+    triggers: routine.triggers,
+    enabled: routine.enabled,
+    startCount: routine.startCount,
+  };
+}
+
 export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): AgentWorkspaceRuntimeSnapshot {
   const host = readConfigString(context, 'controlPlane.host', '127.0.0.1');
   const port = readConfigNumber(context, 'controlPlane.port', 3421);
@@ -164,31 +221,43 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const personaSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, activeName: '(none)' };
+      if (!shellPaths) return { count: 0, activeName: '(none)', items: [] };
       const snapshot = AgentPersonaRegistry.fromShellPaths(shellPaths).snapshot();
-      return { count: snapshot.personas.length, activeName: snapshot.activePersona?.name ?? '(none)' };
+      return {
+        count: snapshot.personas.length,
+        activeName: snapshot.activePersona?.name ?? '(none)',
+        items: snapshot.personas.map((persona) => summarizePersonaItem(persona, snapshot.activePersonaId)),
+      };
     } catch {
-      return { count: 0, activeName: '(unavailable)' };
+      return { count: 0, activeName: '(unavailable)', items: [] };
     }
   })();
   const skillSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, enabled: 0 };
+      if (!shellPaths) return { count: 0, enabled: 0, items: [] };
       const snapshot = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot();
-      return { count: snapshot.skills.length, enabled: snapshot.enabledSkills.length };
+      return {
+        count: snapshot.skills.length,
+        enabled: snapshot.enabledSkills.length,
+        items: snapshot.skills.map(summarizeSkillItem),
+      };
     } catch {
-      return { count: 0, enabled: 0 };
+      return { count: 0, enabled: 0, items: [] };
     }
   })();
   const routineSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, enabled: 0 };
+      if (!shellPaths) return { count: 0, enabled: 0, items: [] };
       const snapshot = AgentRoutineRegistry.fromShellPaths(shellPaths).snapshot();
-      return { count: snapshot.routines.length, enabled: snapshot.enabledRoutines.length };
+      return {
+        count: snapshot.routines.length,
+        enabled: snapshot.enabledRoutines.length,
+        items: snapshot.routines.map(summarizeRoutineItem),
+      };
     } catch {
-      return { count: 0, enabled: 0 };
+      return { count: 0, enabled: 0, items: [] };
     }
   })();
   const runtimeProfiles = (() => {
@@ -264,10 +333,13 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     sessionMemoryCount,
     localRoutineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
+    localRoutines: routineSnapshot.items,
     localSkillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
+    localSkills: skillSnapshot.items,
     localPersonaCount: personaSnapshot.count,
     activePersonaName: personaSnapshot.activeName,
+    localPersonas: personaSnapshot.items,
     knowledgeRoute: '/api/goodvibes-agent/knowledge',
     knowledgeIsolation: 'agent-only',
     executionPolicy: 'serial-proactive',
@@ -307,6 +379,11 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       { id: 'chat', label: 'Continue assistant chat', detail: 'Close this workspace and type a normal message. Agent work stays serial in the main conversation.', kind: 'guidance', safety: 'safe' },
       { id: 'model', label: 'Choose model', detail: 'Open the model/provider workspace for the Agent chat route.', command: '/model', kind: 'command', safety: 'safe' },
+      { id: 'setup-home', label: 'Setup checklist', detail: 'Jump to the first-run checklist for provider, knowledge, personas, skills, routines, memory, channels, and voice/media.', targetCategoryId: 'setup', kind: 'workspace', safety: 'safe' },
+      { id: 'knowledge-home', label: 'Agent Knowledge', detail: 'Jump to isolated Agent Knowledge status, ingest, search, and review flows.', targetCategoryId: 'knowledge', kind: 'workspace', safety: 'read-only' },
+      { id: 'memory-home', label: 'Memory, skills, routines', detail: 'Jump to local memory, persona, skill, and routine setup. These are core Agent product features.', targetCategoryId: 'memory', kind: 'workspace', safety: 'safe' },
+      { id: 'channels-home', label: 'Channels', detail: 'Jump to companion pairing and channel readiness without changing daemon lifecycle.', targetCategoryId: 'channels', kind: 'workspace', safety: 'read-only' },
+      { id: 'voice-home', label: 'Voice and media', detail: 'Jump to voice, TTS, image input, browser, and node posture setup.', targetCategoryId: 'voice-media', kind: 'workspace', safety: 'safe' },
       { id: 'help', label: 'Browse commands', detail: 'Open registry-driven command help.', command: '/help', kind: 'command', safety: 'safe' },
       { id: 'health', label: 'Review health', detail: 'Show the local health review surface without starting or mutating daemon services.', command: '/health review', kind: 'command', safety: 'read-only' },
     ],
@@ -320,6 +397,15 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       { id: 'config', label: 'Open config workspace', detail: 'Use the TUI-derived fullscreen settings workspace.', command: '/config', kind: 'command', safety: 'safe' },
       { id: 'onboarding', label: 'Open setup wizard', detail: 'Review Agent runtime settings in the fullscreen setup flow.', command: '/onboarding', kind: 'command', safety: 'safe' },
+      { id: 'setup-provider-model', label: 'Provider and model', detail: 'Choose the provider/model route for normal assistant chat.', command: '/model', kind: 'command', safety: 'safe' },
+      { id: 'setup-agent-knowledge', label: 'Agent Knowledge', detail: 'Inspect the isolated Agent Knowledge store before ingesting source-backed material.', command: '/knowledge status', kind: 'command', safety: 'read-only' },
+      { id: 'setup-runtime-profiles', label: 'Runtime profiles', detail: 'Browse starter templates for isolated Agent homes and operator identities.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
+      { id: 'setup-personas', label: 'Personas', detail: 'Create or select the active local Agent persona.', targetCategoryId: 'personas', kind: 'workspace', safety: 'safe' },
+      { id: 'setup-skills', label: 'Skills', detail: 'Create, review, and enable reusable local Agent skills.', targetCategoryId: 'skills', kind: 'workspace', safety: 'safe' },
+      { id: 'setup-routines', label: 'Routines', detail: 'Create, review, and enable local Agent routines before any explicit schedule promotion.', targetCategoryId: 'routines', kind: 'workspace', safety: 'safe' },
+      { id: 'setup-memory', label: 'Local memory', detail: 'Inspect local/session memory; secrets stay rejected or redacted.', command: '/memory', kind: 'command', safety: 'read-only' },
+      { id: 'setup-channels', label: 'Channels', detail: 'Open companion pairing and channel readiness setup.', command: '/pair', kind: 'command', safety: 'safe' },
+      { id: 'setup-voice-media', label: 'Voice and media', detail: 'Open TTS/media settings for voice and image-capable Agent flows.', command: '/config tts', kind: 'command', safety: 'safe' },
       { id: 'provider', label: 'Provider status', detail: 'Review provider/model posture.', command: '/provider', kind: 'command', safety: 'read-only' },
       { id: 'auth', label: 'Auth review', detail: 'Review authentication posture without printing token values.', command: '/auth review', kind: 'command', safety: 'read-only' },
     ],
@@ -395,9 +481,53 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Memory, routines, skills, and personas stay Agent-local until stable shared daemon registry contracts exist. Secrets must not be stored as memory.',
     actions: [
       { id: 'memory', label: 'Open memory', detail: 'Inspect local/session memory commands and surfaces.', command: '/memory', kind: 'command', safety: 'read-only' },
-      { id: 'routines', label: 'Routine library', detail: 'Create, review, enable, and start local Agent routines in the main conversation.', command: '/routines', kind: 'command', safety: 'safe' },
-      { id: 'skills', label: 'Local skill library', detail: 'Create, review, and enable local Agent reusable procedures.', command: '/agent-skills', kind: 'command', safety: 'safe' },
-      { id: 'personas', label: 'Persona library', detail: 'Use local Agent personas to shape serial assistant behavior without spawning background agents.', command: '/personas', kind: 'command', safety: 'safe' },
+      { id: 'personas', label: 'Persona library', detail: 'Open the local persona workspace for active role selection and review.', targetCategoryId: 'personas', kind: 'workspace', safety: 'safe' },
+      { id: 'skills', label: 'Local skill library', detail: 'Open the local skill workspace for reusable procedures and review.', targetCategoryId: 'skills', kind: 'workspace', safety: 'safe' },
+      { id: 'routines', label: 'Routine library', detail: 'Open the local routine workspace for repeatable workflows and schedule promotion review.', targetCategoryId: 'routines', kind: 'workspace', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'personas',
+    group: 'LEARN',
+    label: 'Personas',
+    summary: 'Local behavior profiles for the main assistant.',
+    detail: 'Personas shape the serial Agent in the main conversation. They are not background agents and they never spawn specialist roots.',
+    actions: [
+      { id: 'personas-list', label: 'List personas', detail: 'Print the full local persona library.', command: '/personas list', kind: 'command', safety: 'read-only' },
+      { id: 'personas-active', label: 'Show active persona', detail: 'Inspect the active local persona applied to new turns.', command: '/personas active', kind: 'command', safety: 'read-only' },
+      { id: 'personas-create', label: 'Create persona', detail: 'Create a local persona with real name, summary, and instructions. Placeholder commands are never dispatched.', command: '/personas create --name <name> --description <summary> --body <instructions>', kind: 'command', safety: 'safe' },
+      { id: 'personas-use', label: 'Use persona', detail: 'Activate a local persona by id or name.', command: '/personas use <id>', kind: 'command', safety: 'safe' },
+      { id: 'personas-review', label: 'Review persona', detail: 'Mark a local persona reviewed after inspecting it.', command: '/personas review <id>', kind: 'command', safety: 'safe' },
+      { id: 'personas-clear', label: 'Clear active persona', detail: 'Return to the default Agent policy without deleting any persona.', command: '/personas clear', kind: 'command', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'skills',
+    group: 'LEARN',
+    label: 'Skills',
+    summary: 'Reusable local procedures the assistant can apply on demand.',
+    detail: 'Skills are local, reviewable procedures. Enabled skills inform the main conversation; secret-looking content is rejected.',
+    actions: [
+      { id: 'skills-list', label: 'List skills', detail: 'Print the full local Agent skill library.', command: '/agent-skills list', kind: 'command', safety: 'read-only' },
+      { id: 'skills-enabled', label: 'Enabled skills', detail: 'Show only skills currently injected into Agent guidance.', command: '/agent-skills enabled', kind: 'command', safety: 'read-only' },
+      { id: 'skills-create', label: 'Create skill', detail: 'Create a reusable local procedure with real details. Placeholder commands are never dispatched.', command: '/agent-skills create --name <name> --description <summary> --procedure <steps>', kind: 'command', safety: 'safe' },
+      { id: 'skills-enable', label: 'Enable skill', detail: 'Enable a local Agent skill by id or name.', command: '/agent-skills enable <id>', kind: 'command', safety: 'safe' },
+      { id: 'skills-review', label: 'Review skill', detail: 'Mark a local skill reviewed after inspecting it.', command: '/agent-skills review <id>', kind: 'command', safety: 'safe' },
+    ],
+  },
+  {
+    id: 'routines',
+    group: 'LEARN',
+    label: 'Routines',
+    summary: 'Repeatable workflows for the main conversation.',
+    detail: 'Routines run in the main conversation by default. Promotion to an external daemon schedule requires a real schedule command and --yes.',
+    actions: [
+      { id: 'routines-list', label: 'List routines', detail: 'Print the full local Agent routine library.', command: '/routines list', kind: 'command', safety: 'read-only' },
+      { id: 'routines-enabled', label: 'Enabled routines', detail: 'Show routines available for direct use.', command: '/routines enabled', kind: 'command', safety: 'read-only' },
+      { id: 'routines-create', label: 'Create routine', detail: 'Create a repeatable workflow with real steps. Placeholder commands are never dispatched.', command: '/routines create --name <name> --description <summary> --steps <steps>', kind: 'command', safety: 'safe' },
+      { id: 'routines-start', label: 'Start routine', detail: 'Start a local routine in the main conversation without creating a hidden job.', command: '/routines start <id>', kind: 'command', safety: 'safe' },
+      { id: 'routines-promote', label: 'Promote to schedule', detail: 'Create an external daemon schedule from a reviewed routine only with real timing and --yes.', command: '/routines promote <id> --cron <expr> --yes', kind: 'command', safety: 'safe' },
+      { id: 'routines-receipts', label: 'Promotion receipts', detail: 'Inspect local redacted routine schedule promotion receipts.', command: '/routines receipts', kind: 'command', safety: 'read-only' },
     ],
   },
   {
@@ -566,6 +696,31 @@ export class AgentWorkspace {
     const action = this.selectedAction;
     if (!action) return;
     if (action.kind === 'guidance' || !action.command) {
+      if (action.kind === 'workspace' && action.targetCategoryId) {
+        const targetIndex = this.categories.findIndex((category) => category.id === action.targetCategoryId);
+        if (targetIndex >= 0) {
+          this.selectedCategoryIndex = targetIndex;
+          this.selectedActionIndex = 0;
+          this.focusActions();
+          this.status = `Opened ${this.selectedCategory.label}.`;
+          this.lastActionResult = {
+            kind: 'refreshed',
+            title: `Opened ${this.selectedCategory.label}`,
+            detail: action.detail,
+            safety: action.safety,
+          };
+          this.clampSelection();
+          return;
+        }
+        this.status = `Workspace area unavailable: ${action.targetCategoryId}.`;
+        this.lastActionResult = {
+          kind: 'error',
+          title: 'Workspace area unavailable',
+          detail: `No Agent workspace category exists for ${action.targetCategoryId}.`,
+          safety: action.safety,
+        };
+        return;
+      }
       this.status = action.detail;
       this.lastActionResult = {
         kind: 'guidance',

package/src/panels/builtin/knowledge.ts

@@ -6,14 +6,14 @@ import type { ResolvedBuiltinPanelDeps } from './shared.ts';
 export function registerKnowledgePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
   if (!deps.memoryRegistry) return;
 
-  const { memoryRegistry } = deps;
+  const { agentKnowledgeService, memoryRegistry } = deps;
   manager.registerType({
     id: 'knowledge',
     name: 'Knowledge',
     icon: 'K',
     category: 'agent',
-    description: 'Structured project knowledge: risks, runbooks, architecture notes, incidents, and durable facts',
-    factory: () => new KnowledgePanel(memoryRegistry),
+    description: 'Isolated Agent Knowledge plus local non-secret memory review',
+    factory: () => new KnowledgePanel(memoryRegistry, agentKnowledgeService ?? null),
   });
   manager.registerType({
     id: 'memory',

package/src/panels/builtin/shared.ts

@@ -21,6 +21,7 @@ import type { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
 import type { ExecutionPlanManager } from '@pellux/goodvibes-sdk/platform/core';
 import type { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
 import type { ProjectPlanningService } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { KnowledgeService } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { ApiTokenAuditor } from '@pellux/goodvibes-sdk/platform/security';
 import type { ComponentHealthMonitor } from '../../runtime/perf/panel-health-monitor.ts';
 import type { WorktreeRegistry } from '@/runtime/index.ts';
@@ -65,6 +66,8 @@ export interface BuiltinPanelDeps {
   evalRegistry?: import('../eval-panel.ts').EvalRegistry;
   /** MemoryRegistry for the Memory panel. */
   memoryRegistry?: MemoryRegistry;
+  /** Isolated Agent Knowledge service for the Agent Knowledge panel. */
+  agentKnowledgeService?: Pick<KnowledgeService, 'getStatus'>;
   /** Shared policy runtime state for governance/policy diagnostics. */
   policyRuntimeState?: import('@/runtime/index.ts').PolicyRuntimeState;
   /** Approval broker for control-plane/operator panels. */

package/src/panels/knowledge-panel.ts

@@ -2,9 +2,9 @@ import type { Line } from '../types/grid.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import type { MemoryClass, MemoryRecord, MemoryRegistry, MemoryReviewState } from '@pellux/goodvibes-sdk/platform/state';
+import type { KnowledgeStatus } from '@pellux/goodvibes-sdk/platform/knowledge';
 import {
   buildBodyText,
-  buildEmptyState,
   buildGuidanceLine,
   buildKeyValueLine,
   buildPanelLine,
@@ -12,6 +12,10 @@ import {
   DEFAULT_PANEL_PALETTE,
 } from './polish.ts';
 
+export interface AgentKnowledgePanelService {
+  readonly getStatus: () => Promise<KnowledgeStatus & { readonly note?: string }>;
+}
+
 function summarize(records: MemoryRecord[], cls: MemoryClass): MemoryRecord[] {
   return records.filter((record) => record.cls === cls).slice(0, 3);
 }
@@ -42,19 +46,25 @@ function formatConfidence(confidence: number): string {
 
 export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
   private readonly registry: MemoryRegistry;
+  private readonly agentKnowledgeService: AgentKnowledgePanelService | null;
   private unsubscribe?: () => void;
   private records: MemoryRecord[] = [];
+  private agentKnowledgeStatus: (KnowledgeStatus & { readonly note?: string }) | null = null;
+  private agentKnowledgeError: string | null = null;
+  private agentKnowledgeLoading = false;
   // I1: confirm for destructive review-state mutations
   private confirm: ConfirmState<{ id: string; action: 'stale' | 'contradicted' }> | null = null;
 
-  public constructor(registry: MemoryRegistry) {
+  public constructor(registry: MemoryRegistry, agentKnowledgeService: AgentKnowledgePanelService | null = null) {
     super('knowledge', 'Knowledge', 'K', 'agent');
     this.registry = registry;
+    this.agentKnowledgeService = agentKnowledgeService;
   }
 
   public override onActivate(): void {
     super.onActivate();
     this.refresh();
+    this.refreshAgentKnowledgeStatus();
     this.unsubscribe = this.registry.subscribe(() => {
       this.refresh();
       this.markDirty();
@@ -89,12 +99,13 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
   }
 
   protected override getPalette() { return C; }
-  protected override getEmptyStateMessage() { return 'No durable project knowledge'; }
+  protected override getEmptyStateMessage() { return 'No Agent Knowledge sources or local memory review records'; }
   protected override getEmptyStateActions() {
     return [
-      { command: '/recall add fact <summary>', summary: 'capture a durable fact directly' },
-      { command: '/recall capture incident latest', summary: 'promote the latest incident into project memory' },
-      { command: '/recall capture policy', summary: 'store the current policy posture as durable evidence' },
+      { command: '/knowledge status', summary: 'inspect the isolated Agent Knowledge store' },
+      { command: '/knowledge ingest-url <url> --yes', summary: 'ingest source-backed material into Agent Knowledge only' },
+      { command: '/knowledge queue', summary: 'review Agent Knowledge issues' },
+      { command: '/recall add fact <summary>', summary: 'capture a local non-secret memory record when appropriate' },
     ];
   }
 
@@ -198,6 +209,64 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
     this.clampSelection();
   }
 
+  private refreshAgentKnowledgeStatus(): void {
+    if (!this.agentKnowledgeService || this.agentKnowledgeLoading) return;
+    this.agentKnowledgeLoading = true;
+    this.agentKnowledgeError = null;
+    this.agentKnowledgeService.getStatus()
+      .then((status) => {
+        this.agentKnowledgeStatus = status;
+        this.agentKnowledgeError = null;
+      })
+      .catch((error: unknown) => {
+        this.agentKnowledgeError = error instanceof Error ? error.message : String(error);
+      })
+      .finally(() => {
+        this.agentKnowledgeLoading = false;
+        this.markDirty();
+      });
+  }
+
+  private buildAgentKnowledgeHeader(width: number): Line[] {
+    const lines: Line[] = [
+      buildPanelLine(width, [[' Agent Knowledge Segment', C.label]]),
+      buildPanelLine(width, [
+        ['  route ', C.label],
+        ['/api/goodvibes-agent/knowledge/*', C.info],
+        ['  isolated: no default Knowledge/Wiki or HomeGraph fallback', C.dim],
+      ]),
+    ];
+    if (this.agentKnowledgeLoading && !this.agentKnowledgeStatus) {
+      lines.push(buildPanelLine(width, [['  loading isolated Agent Knowledge status...', C.dim]]));
+    } else if (this.agentKnowledgeStatus) {
+      const status = this.agentKnowledgeStatus;
+      lines.push(buildKeyValueLine(width, [
+        { label: 'Ready', value: status.ready ? 'yes' : 'no', valueColor: status.ready ? C.good : C.warn },
+        { label: 'Sources', value: String(status.sourceCount), valueColor: status.sourceCount > 0 ? C.info : C.dim },
+        { label: 'Nodes', value: String(status.nodeCount), valueColor: status.nodeCount > 0 ? C.info : C.dim },
+        { label: 'Issues', value: String(status.issueCount), valueColor: status.issueCount > 0 ? C.warn : C.good },
+      ], C));
+      const note = status.note ? `  note: ${status.note}` : '';
+      lines.push(buildPanelLine(width, [['  storage: ', C.label], [status.storagePath, C.dim], [note, C.dim]]));
+    } else {
+      lines.push(buildPanelLine(width, [['  status: not loaded; /knowledge status uses the same isolated route.', C.dim]]));
+    }
+    if (this.agentKnowledgeError) {
+      lines.push(...buildBodyText(width, `Agent Knowledge status warning: ${this.agentKnowledgeError}`, C, C.warn));
+    }
+    lines.push(buildPanelLine(width, [
+      ['  actions ', C.label],
+      ['/knowledge status', C.value],
+      [' | ', C.dim],
+      ['/knowledge ingest-url <url> --yes', C.value],
+      [' | ', C.dim],
+      ['/knowledge search <query>', C.value],
+      [' | ', C.dim],
+      ['/knowledge queue', C.value],
+    ]));
+    return lines;
+  }
+
   public render(width: number, height: number): Line[] {
     this.clampSelection();
 
@@ -214,12 +283,14 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
 
     if (this.records.length === 0) this.refresh();
 
-    const intro = 'Typed project knowledge, reviewed evidence, and operator-governed memory across session, project, and team scopes.';
+    const intro = 'Isolated Agent Knowledge plus local non-secret memory review. This surface never falls back to default Knowledge/Wiki or HomeGraph.';
     const records = this.registry.search({ limit: 200 });
+    const agentKnowledgeHeader = this.buildAgentKnowledgeHeader(width);
 
     if (records.length === 0) {
       return this.renderList(width, height, {
         title: 'Knowledge Control Room',
+        header: agentKnowledgeHeader,
         footer: [buildPanelLine(width, [[' Review keys: Up/Down move  r/Enter review  s stale  c contradicted  f fresh', C.dim]])],
       });
     }
@@ -334,11 +405,11 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
 
     return this.renderList(width, height, {
       title: 'Knowledge Control Room',
-      header: [...classLines, ...reviewLines],
+      header: [...agentKnowledgeHeader, ...classLines, ...reviewLines],
       footer: [
+        buildPanelLine(width, [['  Up/Down move  r/Enter reviewed  s stale  c contradicted  f fresh', C.dim]]),
         ...(selectedLines.length > 0 ? selectedLines : []),
         ...recentSummaryLines,
-        buildPanelLine(width, [['  Up/Down move  r/Enter reviewed  s stale  c contradicted  f fresh', C.dim]]),
       ],
     });
   }

package/src/renderer/agent-workspace.ts

@@ -67,6 +67,7 @@ function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[
 }
 
 function actionCommand(action: AgentWorkspaceAction): string {
+  if (action.kind === 'workspace') return action.targetCategoryId ? `open ${action.targetCategoryId}` : '(workspace)';
   return action.command ?? '(guidance)';
 }
 
@@ -99,6 +100,40 @@ function setupChecklistLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLi
   return lines;
 }
 
+function localLibraryLines(
+  title: string,
+  items: readonly AgentWorkspaceRuntimeSnapshot['localPersonas'][number][],
+  emptyText: string,
+): ContextLine[] {
+  const lines: ContextLine[] = [
+    { text: title, fg: PALETTE.title, bold: true },
+  ];
+  if (items.length === 0) {
+    lines.push({ text: emptyText, fg: PALETTE.warn });
+    return lines;
+  }
+  for (const item of items.slice(0, 8)) {
+    const status = [
+      item.active ? 'active' : '',
+      item.enabled === true ? 'enabled' : item.enabled === false ? 'disabled' : '',
+      item.reviewState,
+      item.startCount !== undefined ? `starts ${item.startCount}` : '',
+    ].filter(Boolean).join(' / ');
+    const tags = item.tags.length > 0 ? ` tags=${item.tags.join(',')}` : '';
+    const triggers = item.triggers.length > 0 ? ` triggers=${item.triggers.join(',')}` : '';
+    lines.push({
+      text: `${item.id}: ${item.name} (${status})`,
+      fg: item.reviewState === 'stale' ? PALETTE.warn : PALETTE.info,
+      bold: item.active === true,
+    });
+    lines.push({ text: `  ${item.description}${tags}${triggers}`, fg: PALETTE.muted });
+  }
+  if (items.length > 8) {
+    lines.push({ text: `${items.length - 8} more item(s). Open the library command for the full list.`, fg: PALETTE.dim });
+  }
+  return lines;
+}
+
 function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
   if (!snapshot) return [{ text: 'Runtime context is not loaded yet.', fg: PALETTE.warn }];
   const base: ContextLine[] = [{ text: 'Live Agent Context', fg: PALETTE.title, bold: true }];
@@ -177,6 +212,30 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { text: 'Durable memory, routines, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
       { text: 'Secrets are rejected/redacted; store secret references instead of secret values.', fg: PALETTE.warn },
     );
+  } else if (category.id === 'personas') {
+    base.push(
+      { text: `Personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
+      { text: 'Personas are local behavior profiles for the serial main-conversation assistant, not spawned agents.', fg: PALETTE.good },
+      { text: 'Use them for tone, role, domain constraints, tool posture, and repeatable operating preferences.', fg: PALETTE.muted },
+      { text: '' },
+      ...localLibraryLines('Persona Library', snapshot.localPersonas, 'No local personas yet. Create one with /personas create ...'),
+    );
+  } else if (category.id === 'skills') {
+    base.push(
+      { text: `Skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}`, fg: PALETTE.info },
+      { text: 'Skills are reusable local procedures the assistant can apply from the main conversation.', fg: PALETTE.good },
+      { text: 'Enabled skills are injected as operating guidance; secret-looking content is rejected.', fg: PALETTE.warn },
+      { text: '' },
+      ...localLibraryLines('Skill Library', snapshot.localSkills, 'No local skills yet. Create one with /agent-skills create ...'),
+    );
+  } else if (category.id === 'routines') {
+    base.push(
+      { text: `Routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
+      { text: 'Routines are repeatable main-conversation workflows. Starting one does not create hidden jobs.', fg: PALETTE.good },
+      { text: 'Scheduling a reviewed routine is explicit and writes to the externally owned daemon only with --yes.', fg: PALETTE.warn },
+      { text: '' },
+      ...localLibraryLines('Routine Library', snapshot.localRoutines, 'No local routines yet. Create one with /routines create ...'),
+    );
   } else if (category.id === 'work') {
     base.push(
       { text: 'Work plan and approvals are read or explicitly confirmed through public operator routes.', fg: PALETTE.info },

package/src/runtime/bootstrap-core.ts

@@ -30,6 +30,7 @@ import { registerBootstrapRuntimeEvents } from '@/runtime/index.ts';
 import { createRuntimeServices, type RuntimeServices } from './services.ts';
 import { createUiRuntimeServices, type UiRuntimeServices } from './ui-services.ts';
 import { installAgentToolPolicyGuard } from '../tools/wrfc-agent-guard.ts';
+import { registerAgentLocalRegistryTool } from '../tools/agent-local-registry-tool.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 
 export interface BootstrapCoreState {
@@ -227,6 +228,7 @@ export async function initializeBootstrapCore(
     overflowHandler: services.overflowHandler,
     changeTracker: services.sessionChangeTracker,
   });
+  registerAgentLocalRegistryTool(toolRegistry, services.shellPaths);
   installAgentToolPolicyGuard(toolRegistry, {
     getLastUserMessage: () => conversation.getLastUserMessage(),
   });

package/src/runtime/bootstrap-shell.ts

@@ -135,6 +135,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     sandboxSessionRegistry: services.sandboxSessionRegistry,
     systemMessagesPanel,
     memoryRegistry: services.memoryRegistry,
+    agentKnowledgeService: services.agentKnowledgeService,
     uiServices,
     pluginManager: services.pluginManager,
     hookDispatcher: services.hookDispatcher,

package/src/runtime/bootstrap.ts

@@ -48,6 +48,7 @@ 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 daemon/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
   '- GoodVibes Agent connects to an externally managed GoodVibes daemon. Do not start, stop, restart, install, expose, or mutate daemon/listener/control-plane surface 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.',
   '- 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.',

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

@@ -0,0 +1,341 @@
+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 { 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';
+
+export type AgentLocalRegistryDomain = 'persona' | 'skill' | 'routine';
+export type AgentLocalRegistryAction =
+  | 'list'
+  | 'search'
+  | 'get'
+  | 'create'
+  | 'update'
+  | 'enable'
+  | 'disable'
+  | 'review'
+  | 'stale'
+  | 'use'
+  | 'clear_active'
+  | 'start';
+
+export interface AgentLocalRegistryToolArgs {
+  readonly domain?: unknown;
+  readonly action?: unknown;
+  readonly id?: unknown;
+  readonly query?: unknown;
+  readonly name?: unknown;
+  readonly description?: unknown;
+  readonly body?: unknown;
+  readonly procedure?: unknown;
+  readonly steps?: unknown;
+  readonly triggers?: unknown;
+  readonly tags?: unknown;
+  readonly reason?: unknown;
+  readonly enabled?: unknown;
+  readonly provenance?: unknown;
+}
+
+const DOMAINS: readonly AgentLocalRegistryDomain[] = ['persona', 'skill', 'routine'];
+const ACTIONS: readonly AgentLocalRegistryAction[] = [
+  'list',
+  'search',
+  'get',
+  'create',
+  'update',
+  'enable',
+  'disable',
+  'review',
+  'stale',
+  'use',
+  'clear_active',
+  'start',
+];
+
+function isDomain(value: unknown): value is AgentLocalRegistryDomain {
+  return typeof value === 'string' && DOMAINS.includes(value as AgentLocalRegistryDomain);
+}
+
+function isAction(value: unknown): value is AgentLocalRegistryAction {
+  return typeof value === 'string' && ACTIONS.includes(value as AgentLocalRegistryAction);
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readStringList(value: unknown): readonly string[] {
+  if (typeof value === 'string') {
+    return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+  }
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function registryError(message: string): { readonly success: false; readonly error: string } {
+  return { success: false, error: message };
+}
+
+function registryOutput(output: string): { readonly success: true; readonly output: string } {
+  return { success: true, output };
+}
+
+function requireId(args: AgentLocalRegistryToolArgs): string {
+  const id = readString(args.id);
+  if (!id) throw new Error('id is required.');
+  return id;
+}
+
+function requireName(args: AgentLocalRegistryToolArgs): string {
+  const name = readString(args.name);
+  if (!name) throw new Error('name is required.');
+  return name;
+}
+
+function requireDescription(args: AgentLocalRegistryToolArgs): string {
+  const description = readString(args.description);
+  if (!description) throw new Error('description is required.');
+  return description;
+}
+
+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}`;
+}
+
+function formatSkill(skill: AgentSkillRecord): string {
+  const enabled = skill.enabled ? 'enabled' : 'disabled';
+  return `${skill.id}  ${enabled}  ${skill.reviewState}  ${skill.name} - ${skill.description}`;
+}
+
+function formatRoutine(routine: AgentRoutineRecord): string {
+  const enabled = routine.enabled ? 'enabled' : 'disabled';
+  return `${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}`;
+}
+
+function listPersonas(registry: AgentPersonaRegistry, records: readonly AgentPersonaRecord[], title: string): string {
+  const snapshot = registry.snapshot();
+  return records.length === 0
+    ? `${title}\nNo Agent-local personas.`
+    : [title, ...records.map((persona) => formatPersona(persona, snapshot.activePersonaId))].join('\n');
+}
+
+function listSkills(records: readonly AgentSkillRecord[], title: string): string {
+  return records.length === 0
+    ? `${title}\nNo Agent-local skills.`
+    : [title, ...records.map(formatSkill)].join('\n');
+}
+
+function listRoutines(records: readonly AgentRoutineRecord[], title: string): string {
+  return records.length === 0
+    ? `${title}\nNo Agent-local routines.`
+    : [title, ...records.map(formatRoutine)].join('\n');
+}
+
+function handlePersona(shellPaths: ShellPathService, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): string {
+  const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+  if (action === 'list') return listPersonas(registry, registry.list(), 'Agent-local personas');
+  if (action === 'search') return listPersonas(registry, registry.search(readString(args.query)), 'Agent-local personas search');
+  if (action === 'get') {
+    const persona = registry.get(requireId(args));
+    if (!persona) return `Unknown Agent-local persona: ${readString(args.id)}`;
+    return [
+      formatPersona(persona, registry.snapshot().activePersonaId),
+      `triggers: ${persona.triggers.join(', ') || '(manual)'}`,
+      `tags: ${persona.tags.join(', ') || '(none)'}`,
+      '',
+      persona.body,
+    ].join('\n');
+  }
+  if (action === 'create') {
+    const persona = registry.create({
+      name: requireName(args),
+      description: requireDescription(args),
+      body: readString(args.body),
+      tags: readStringList(args.tags),
+      triggers: readStringList(args.triggers),
+      source: 'agent',
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Created Agent-local persona ${persona.id}: ${persona.name}`;
+  }
+  if (action === 'update') {
+    const persona = registry.update(requireId(args), {
+      name: readString(args.name) || undefined,
+      description: readString(args.description) || undefined,
+      body: readString(args.body) || undefined,
+      tags: args.tags === undefined ? undefined : readStringList(args.tags),
+      triggers: args.triggers === undefined ? undefined : readStringList(args.triggers),
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Updated Agent-local persona ${persona.id}: ${persona.name}`;
+  }
+  if (action === 'use') {
+    const persona = registry.setActive(requireId(args));
+    return `Active Agent-local persona set to ${persona.id}: ${persona.name}`;
+  }
+  if (action === 'clear_active') {
+    registry.clearActive();
+    return 'Cleared active Agent-local persona.';
+  }
+  if (action === 'review') return `Reviewed Agent-local persona ${registry.markReviewed(requireId(args)).id}.`;
+  if (action === 'stale') return `Marked Agent-local persona ${registry.markStale(requireId(args), readString(args.reason)).id} stale.`;
+  throw new Error(`Action ${action} is not valid for personas.`);
+}
+
+function handleSkill(shellPaths: ShellPathService, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): string {
+  const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+  if (action === 'list') return listSkills(registry.list(), 'Agent-local skills');
+  if (action === 'search') return listSkills(registry.search(readString(args.query)), 'Agent-local skills search');
+  if (action === 'get') {
+    const skill = registry.get(requireId(args));
+    if (!skill) return `Unknown Agent-local skill: ${readString(args.id)}`;
+    return [
+      formatSkill(skill),
+      `triggers: ${skill.triggers.join(', ') || '(manual)'}`,
+      `tags: ${skill.tags.join(', ') || '(none)'}`,
+      '',
+      skill.procedure,
+    ].join('\n');
+  }
+  if (action === 'create') {
+    const skill = registry.create({
+      name: requireName(args),
+      description: requireDescription(args),
+      procedure: readString(args.procedure),
+      triggers: readStringList(args.triggers),
+      tags: readStringList(args.tags),
+      enabled: args.enabled === true,
+      source: 'agent',
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Created Agent-local skill ${skill.id}: ${skill.name}`;
+  }
+  if (action === 'update') {
+    const skill = registry.update(requireId(args), {
+      name: readString(args.name) || undefined,
+      description: readString(args.description) || undefined,
+      procedure: readString(args.procedure) || undefined,
+      triggers: args.triggers === undefined ? undefined : readStringList(args.triggers),
+      tags: args.tags === undefined ? undefined : readStringList(args.tags),
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Updated Agent-local skill ${skill.id}: ${skill.name}`;
+  }
+  if (action === 'enable' || action === 'disable') {
+    const skill = registry.setEnabled(requireId(args), action === 'enable');
+    return `${action === 'enable' ? 'Enabled' : 'Disabled'} Agent-local skill ${skill.id}: ${skill.name}`;
+  }
+  if (action === 'review') return `Reviewed Agent-local skill ${registry.markReviewed(requireId(args)).id}.`;
+  if (action === 'stale') return `Marked Agent-local skill ${registry.markStale(requireId(args), readString(args.reason)).id} stale.`;
+  throw new Error(`Action ${action} is not valid for skills.`);
+}
+
+function handleRoutine(shellPaths: ShellPathService, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): string {
+  const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
+  if (action === 'list') return listRoutines(registry.list(), 'Agent-local routines');
+  if (action === 'search') return listRoutines(registry.search(readString(args.query)), 'Agent-local routines search');
+  if (action === 'get') {
+    const routine = registry.get(requireId(args));
+    if (!routine) return `Unknown Agent-local routine: ${readString(args.id)}`;
+    return [
+      formatRoutine(routine),
+      `triggers: ${routine.triggers.join(', ') || '(manual)'}`,
+      `tags: ${routine.tags.join(', ') || '(none)'}`,
+      '',
+      routine.steps,
+    ].join('\n');
+  }
+  if (action === 'create') {
+    const routine = registry.create({
+      name: requireName(args),
+      description: requireDescription(args),
+      steps: readString(args.steps),
+      triggers: readStringList(args.triggers),
+      tags: readStringList(args.tags),
+      enabled: args.enabled === true,
+      source: 'agent',
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Created Agent-local routine ${routine.id}: ${routine.name}`;
+  }
+  if (action === 'update') {
+    const routine = registry.update(requireId(args), {
+      name: readString(args.name) || undefined,
+      description: readString(args.description) || undefined,
+      steps: readString(args.steps) || undefined,
+      triggers: args.triggers === undefined ? undefined : readStringList(args.triggers),
+      tags: args.tags === undefined ? undefined : readStringList(args.tags),
+      provenance: readString(args.provenance) || 'agent-local-registry-tool',
+    });
+    return `Updated Agent-local routine ${routine.id}: ${routine.name}`;
+  }
+  if (action === 'enable' || action === 'disable') {
+    const routine = registry.setEnabled(requireId(args), action === 'enable');
+    return `${action === 'enable' ? 'Enabled' : 'Disabled'} Agent-local routine ${routine.id}: ${routine.name}`;
+  }
+  if (action === 'start') {
+    const routine = registry.markStarted(requireId(args));
+    return [
+      `Started Agent-local routine ${routine.id}: ${routine.name}`,
+      'Policy: same main conversation; no hidden background job, daemon mutation, or external side effect was started.',
+      '',
+      routine.steps,
+    ].join('\n');
+  }
+  if (action === 'review') return `Reviewed Agent-local routine ${registry.markReviewed(requireId(args)).id}.`;
+  if (action === 'stale') return `Marked Agent-local routine ${registry.markStale(requireId(args), readString(args.reason)).id} stale.`;
+  throw new Error(`Action ${action} is not valid for routines.`);
+}
+
+export function createAgentLocalRegistryTool(shellPaths: ShellPathService): 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.',
+      ].join(' '),
+      parameters: {
+        type: 'object',
+        properties: {
+          domain: { type: 'string', enum: [...DOMAINS] },
+          action: { type: 'string', enum: [...ACTIONS] },
+          id: { type: 'string' },
+          query: { type: 'string' },
+          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.' },
+          triggers: { type: 'array', items: { type: 'string' } },
+          tags: { type: 'array', items: { type: 'string' } },
+          reason: { type: 'string' },
+          enabled: { type: 'boolean' },
+          provenance: { type: 'string' },
+        },
+        required: ['domain', 'action'],
+        additionalProperties: false,
+      },
+      sideEffects: ['state'],
+    },
+    execute: async (rawArgs: unknown) => {
+      const args = rawArgs as AgentLocalRegistryToolArgs;
+      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 === 'persona') return registryOutput(handlePersona(shellPaths, args.action, args));
+        if (args.domain === 'skill') return registryOutput(handleSkill(shellPaths, args.action, args));
+        return registryOutput(handleRoutine(shellPaths, args.action, args));
+      } catch (error) {
+        return registryError(error instanceof Error ? error.message : String(error));
+      }
+    },
+  };
+}
+
+export function registerAgentLocalRegistryTool(registry: ToolRegistry, shellPaths: ShellPathService): void {
+  registry.register(createAgentLocalRegistryTool(shellPaths));
+}

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.48';
+let _version = '0.1.50';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {