@pellux/goodvibes-agent 0.1.48 → 0.1.49

package/CHANGELOG.md

@@ -2,10 +2,16 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 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.49",
   "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

@@ -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';
 }
@@ -307,6 +308,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 +326,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.', command: '/personas', kind: 'command', safety: 'safe' },
+      { id: 'setup-skills', label: 'Skills', detail: 'Create, review, and enable reusable local Agent skills.', command: '/agent-skills', kind: 'command', safety: 'safe' },
+      { id: 'setup-routines', label: 'Routines', detail: 'Create, review, and enable local Agent routines before any explicit schedule promotion.', command: '/routines', kind: 'command', 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' },
     ],
@@ -566,6 +581,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)';
 }
 

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