@pellux/goodvibes-agent 0.1.103 → 0.1.105

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.105 - 2026-06-01
+
+- 7ea88c8 Remove development panel surface
+
+## 0.1.104 - 2026-06-01
+
+- 37fe253 Add Agent memory workspace controls
+
 ## 0.1.103 - 2026-06-01
 
 - ed9895a Add CLI controls for Agent memory

package/package.json

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

package/src/agent/memory-safety.ts

@@ -0,0 +1,16 @@
+const SECRET_PATTERNS: readonly RegExp[] = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/i,
+  /\bsk-[A-Za-z0-9_-]{16,}\b/,
+  /\bgh[pousr]_[A-Za-z0-9_]{16,}\b/i,
+  /\b(?:password|passwd|api[_-]?key|token|secret)\s*[:=]\s*\S{6,}/i,
+];
+
+export function containsSecretLikeText(text: string): boolean {
+  return SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+export function assertNoSecretLikeMemoryText(fields: readonly string[]): void {
+  if (fields.some((field) => containsSecretLikeText(field))) {
+    throw new Error('Agent memory cannot store secret-looking values. Store a secret reference or remove the sensitive text.');
+  }
+}

package/src/cli/memory-command.ts

@@ -16,6 +16,7 @@ import {
   type ProvenanceLink,
   type ProvenanceLinkKind,
 } from '@pellux/goodvibes-sdk/platform/state';
+import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import type { CliCommandOutput } from './types.ts';
 import type { CliCommandRuntime } from './management.ts';
@@ -40,13 +41,6 @@ const VALUE_OPTIONS = new Set([
   'task',
   'turn',
 ]);
-const SECRET_PATTERNS: readonly RegExp[] = [
-  /-----BEGIN [A-Z ]*PRIVATE KEY-----/i,
-  /\bsk-[A-Za-z0-9_-]{16,}\b/,
-  /\bgh[pousr]_[A-Za-z0-9_]{16,}\b/i,
-  /\b(?:password|passwd|api[_-]?key|token|secret)\s*[:=]\s*\S{6,}/i,
-];
-
 interface CommandSuccess<TData> {
   readonly ok: true;
   readonly kind: string;
@@ -197,16 +191,6 @@ function optionalClass(value: string | undefined): MemoryClass | undefined {
   return requireClass(value);
 }
 
-function containsSecretLikeText(text: string): boolean {
-  return SECRET_PATTERNS.some((pattern) => pattern.test(text));
-}
-
-function assertNoSecretLikeText(fields: readonly string[]): void {
-  if (fields.some((field) => containsSecretLikeText(field))) {
-    throw new Error('Agent memory cannot store secret-looking values. Store a secret reference or remove the sensitive text.');
-  }
-}
-
 function timestamp(value: number): string {
   return new Date(value).toISOString().slice(0, 19).replace('T', ' ');
 }
@@ -385,7 +369,7 @@ function readBundle(path: string): MemoryBundle {
   const parsed: unknown = JSON.parse(readFileSync(path, 'utf-8'));
   if (!isMemoryBundle(parsed)) throw new Error('Invalid Agent memory bundle.');
   for (const record of parsed.records) {
-    assertNoSecretLikeText([
+    assertNoSecretLikeMemoryText([
       record.summary,
       record.detail ?? '',
       ...record.tags,
@@ -454,7 +438,7 @@ async function handleAdd(runtime: CliCommandRuntime, context: MemoryContext, arg
   if (!summary) return failure(runtime, 'invalid_memory_command', 'Usage: goodvibes-agent memory add <class> <summary> [--scope <scope>] [--detail <text>] [--tags a,b]', 2);
   const detail = optionValue(options, 'detail');
   const tags = csvOption(options, 'tags');
-  assertNoSecretLikeText([summary, detail ?? '', ...(tags ?? [])]);
+  assertNoSecretLikeMemoryText([summary, detail ?? '', ...(tags ?? [])]);
   const reviewState = optionValue(options, 'review-state');
   if (reviewState !== undefined && !isReviewState(reviewState)) {
     return failure(runtime, 'invalid_memory_command', `Invalid review state "${reviewState}". Valid: ${VALID_REVIEW_STATES.join(', ')}`, 2);

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

@@ -0,0 +1,170 @@
+import { createLocalEditor, createProfileEditor } from './agent-workspace-editors.ts';
+import type {
+  AgentWorkspaceActionResult,
+  AgentWorkspaceCategory,
+  AgentWorkspaceCommandDispatcher,
+  AgentWorkspaceFocusPane,
+  AgentWorkspaceLocalEditor,
+  AgentWorkspaceLocalEditorKind,
+  AgentWorkspaceLocalOperation,
+  AgentWorkspaceRuntimeSnapshot,
+} from './agent-workspace-types.ts';
+
+interface AgentWorkspaceActivationHost {
+  readonly categories: readonly AgentWorkspaceCategory[];
+  readonly selectedCategory: AgentWorkspaceCategory;
+  readonly selectedAction: AgentWorkspaceCategory['actions'][number] | null;
+  readonly runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null;
+  localEditor: AgentWorkspaceLocalEditor | null;
+  focusPane: AgentWorkspaceFocusPane;
+  selectedCategoryIndex: number;
+  selectedActionIndex: number;
+  status: string;
+  lastActionResult: AgentWorkspaceActionResult | null;
+  submitEditorFieldOrForm(requestRender?: () => void): void;
+  focusActions(): void;
+  clampSelection(): void;
+  moveLocalLibraryItemSelection(kind: AgentWorkspaceLocalEditorKind, delta: number): void;
+  applyLocalLibraryOperation(operation: AgentWorkspaceLocalOperation): void;
+  hasCommandDispatch(): boolean;
+  dispatchWorkspaceCommand: AgentWorkspaceCommandDispatcher;
+}
+
+function parseCommand(command: string): { readonly name: string; readonly args: readonly string[] } {
+  const trimmed = command.trim().replace(/^\//, '');
+  if (!trimmed) return { name: '', args: [] };
+  const parts = trimmed.split(/\s+/);
+  return { name: parts[0] ?? '', args: parts.slice(1) };
+}
+
+export function activateAgentWorkspaceSelection(
+  workspace: AgentWorkspaceActivationHost,
+  requestRender?: () => void,
+): void {
+  if (workspace.localEditor) {
+    workspace.submitEditorFieldOrForm(requestRender);
+    return;
+  }
+  if (workspace.focusPane === 'categories') {
+    workspace.focusActions();
+    return;
+  }
+  const action = workspace.selectedAction;
+  if (!action) return;
+  if (action.kind === 'editor' && action.editorKind) {
+    workspace.localEditor = action.editorKind === 'profile'
+      ? createProfileEditor(workspace.runtimeSnapshot?.runtimeStarterTemplates ?? [])
+      : createLocalEditor(action.editorKind);
+    workspace.status = `Editing ${workspace.localEditor.title}.`;
+    workspace.lastActionResult = {
+      kind: 'guidance',
+      title: workspace.localEditor.title,
+      detail: workspace.localEditor.message,
+      safety: action.safety,
+    };
+    return;
+  }
+  if (action.kind === 'local-selection' && action.localKind) {
+    workspace.moveLocalLibraryItemSelection(action.localKind, action.selectionDelta ?? 0);
+    return;
+  }
+  if (action.kind === 'local-operation' && action.localOperation) {
+    workspace.applyLocalLibraryOperation(action.localOperation);
+    return;
+  }
+  if (action.kind === 'guidance' || !action.command) {
+    handleGuidanceOrWorkspaceAction(workspace, action);
+    return;
+  }
+  if (action.safety === 'blocked') {
+    workspace.status = `Blocked here: ${action.label}.`;
+    workspace.lastActionResult = {
+      kind: 'blocked',
+      title: `${action.label} is blocked in Agent`,
+      detail: action.detail,
+      command: action.command,
+      safety: action.safety,
+    };
+    return;
+  }
+  const parsed = parseCommand(action.command);
+  if (!parsed.name) {
+    workspace.status = `No command is configured for ${action.label}.`;
+    workspace.lastActionResult = {
+      kind: 'error',
+      title: 'Command unavailable',
+      detail: `No command is configured for ${action.label}.`,
+      safety: action.safety,
+    };
+    return;
+  }
+  if (/<[^>\s]+(?:\s+[^>]*)?>/.test(action.command)) {
+    workspace.status = `Placeholder command not dispatched: ${action.command}.`;
+    workspace.lastActionResult = {
+      kind: 'guidance',
+      title: `${action.label} needs details`,
+      detail: 'This action is a command template. Close the workspace and run it with real task text instead of placeholder values.',
+      command: action.command,
+      safety: action.safety,
+    };
+    return;
+  }
+  if (!workspace.hasCommandDispatch()) {
+    workspace.status = `Command dispatch is not available for ${action.command}.`;
+    workspace.lastActionResult = {
+      kind: 'error',
+      title: 'Command dispatch unavailable',
+      detail: `The command ${action.command} cannot be opened from this runtime.`,
+      command: action.command,
+      safety: action.safety,
+    };
+    return;
+  }
+  workspace.status = `Opening ${action.command}.`;
+  workspace.lastActionResult = {
+    kind: 'dispatched',
+    title: `Opening ${action.label}`,
+    detail: 'The workspace handed this safe or read-only command to the shell-owned command router.',
+    command: action.command,
+    safety: action.safety,
+  };
+  workspace.dispatchWorkspaceCommand(action.command);
+}
+
+function handleGuidanceOrWorkspaceAction(
+  workspace: AgentWorkspaceActivationHost,
+  action: AgentWorkspaceCategory['actions'][number],
+): void {
+  if (action.kind === 'workspace' && action.targetCategoryId) {
+    const targetIndex = workspace.categories.findIndex((category) => category.id === action.targetCategoryId);
+    if (targetIndex >= 0) {
+      workspace.selectedCategoryIndex = targetIndex;
+      workspace.selectedActionIndex = 0;
+      workspace.focusActions();
+      workspace.status = `Opened ${workspace.selectedCategory.label}.`;
+      workspace.lastActionResult = {
+        kind: 'refreshed',
+        title: `Opened ${workspace.selectedCategory.label}`,
+        detail: action.detail,
+        safety: action.safety,
+      };
+      workspace.clampSelection();
+      return;
+    }
+    workspace.status = `Workspace area unavailable: ${action.targetCategoryId}.`;
+    workspace.lastActionResult = {
+      kind: 'error',
+      title: 'Workspace area unavailable',
+      detail: `No Agent workspace category exists for ${action.targetCategoryId}.`,
+      safety: action.safety,
+    };
+    return;
+  }
+  workspace.status = action.detail;
+  workspace.lastActionResult = {
+    kind: 'guidance',
+    title: action.label,
+    detail: action.detail,
+    safety: action.safety,
+  };
+}

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

@@ -110,7 +110,14 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     summary: 'Local assistant memory, routines, skills, and reusable behavior.',
     detail: 'Memory, routines, skills, and personas stay Agent-local until stable shared registry contracts exist. Secrets must not be stored as memory.',
     actions: [
-      { id: 'memory', label: 'Open memory', detail: 'Inspect local/session memory records and commands.', command: '/memory', kind: 'command', safety: 'read-only' },
+      { id: 'memory-list', label: 'List memory', detail: 'Print the full Agent-owned memory list.', command: '/memory list', kind: 'command', safety: 'read-only' },
+      { id: 'memory-prev', label: 'Previous memory', detail: 'Move the local memory selection up without changing review state.', localKind: 'memory', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
+      { id: 'memory-next', label: 'Next memory', detail: 'Move the local memory selection down without changing review state.', localKind: 'memory', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
+      { id: 'memory-create', label: 'Create memory', detail: 'Open an in-workspace form for a durable, non-secret Agent memory. No default wiki fallback is used.', editorKind: 'memory', kind: 'editor', safety: 'safe' },
+      { id: 'memory-edit', label: 'Edit selected memory', detail: 'Open the selected Agent memory in an in-workspace editor.', localKind: 'memory', localOperation: 'memory-edit', kind: 'local-operation', safety: 'safe' },
+      { id: 'memory-review', label: 'Review selected', detail: 'Mark the selected Agent memory reviewed after inspecting it.', localKind: 'memory', localOperation: 'memory-review', kind: 'local-operation', safety: 'safe' },
+      { id: 'memory-stale', label: 'Mark selected stale', detail: 'Mark the selected Agent memory stale so it stops being trusted until reviewed.', localKind: 'memory', localOperation: 'memory-stale', kind: 'local-operation', safety: 'safe' },
+      { id: 'memory-delete', label: 'Delete selected memory', detail: 'Open a confirmation form before deleting the selected Agent memory.', localKind: 'memory', localOperation: 'memory-delete', kind: 'local-operation', 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' },

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

@@ -1,6 +1,7 @@
 import type { AgentPersonaRecord } from '../agent/persona-registry.ts';
 import type { AgentRoutineRecord } from '../agent/routine-registry.ts';
 import type { AgentSkillRecord } from '../agent/skill-registry.ts';
+import type { MemoryRecord } from '@pellux/goodvibes-sdk/platform/state';
 import type {
   AgentWorkspaceLocalEditor,
   AgentWorkspaceLocalEditorKind,
@@ -31,6 +32,23 @@ export function createProfileEditor(templates: readonly AgentWorkspaceRuntimeSta
 
 export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalEditor {
   if (kind === 'profile') return createProfileEditor([]);
+  if (kind === 'memory') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Create Memory',
+      selectedFieldIndex: 0,
+      message: 'Record a durable, non-secret Agent memory. This stays in the Agent-owned memory store and never writes to default Knowledge/Wiki.',
+      fields: [
+        { id: 'cls', label: 'Class', value: 'fact', required: true, multiline: false, hint: 'fact, decision, constraint, incident, pattern, risk, runbook, architecture, or ownership.' },
+        { id: 'scope', label: 'Scope', value: 'project', required: true, multiline: false, hint: 'session, project, or team.' },
+        { id: 'summary', label: 'Summary', value: '', required: true, multiline: false, hint: 'One durable sentence. Do not store secrets.' },
+        { id: 'detail', label: 'Detail', value: '', required: false, multiline: true, hint: 'Optional supporting detail. Ctrl-J inserts a new line.' },
+        { id: 'tags', label: 'Tags', value: '', required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+        { id: 'confidence', label: 'Confidence', value: '80', required: false, multiline: false, hint: '0-100 confidence score.' },
+      ],
+    };
+  }
   if (kind === 'persona') {
     return {
       kind,
@@ -82,6 +100,23 @@ export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWor
   };
 }
 
+export function createMemoryUpdateEditor(record: MemoryRecord): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'memory',
+    mode: 'update',
+    recordId: record.id,
+    title: 'Edit Memory',
+    selectedFieldIndex: 0,
+    message: `Editing ${record.id}. Saving updates only the Agent-owned memory record.`,
+    fields: [
+      { id: 'scope', label: 'Scope', value: record.scope, required: true, multiline: false, hint: 'session, project, or team.' },
+      { id: 'summary', label: 'Summary', value: record.summary, required: true, multiline: false, hint: 'One durable sentence. Do not store secrets.' },
+      { id: 'detail', label: 'Detail', value: record.detail ?? '', required: false, multiline: true, hint: 'Optional supporting detail. Ctrl-J inserts a new line.' },
+      { id: 'tags', label: 'Tags', value: record.tags.join(', '), required: false, multiline: false, hint: 'Comma-separated optional tags.' },
+    ],
+  };
+}
+
 export function createPersonaUpdateEditor(record: AgentPersonaRecord, active: boolean): AgentWorkspaceLocalEditor {
   return {
     kind: 'persona',
@@ -164,6 +199,7 @@ export function isAffirmative(value: string): boolean {
 }
 
 export function editorCategoryId(kind: AgentWorkspaceLocalEditorKind): string {
+  if (kind === 'memory') return 'memory';
   if (kind === 'profile') return 'profiles';
   if (kind === 'persona') return 'personas';
   if (kind === 'skill') return 'skills';

package/src/input/agent-workspace-memory-editor.ts

@@ -0,0 +1,88 @@
+import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { MemoryClass, MemoryRecord, MemoryScope } from '@pellux/goodvibes-sdk/platform/state';
+import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
+import type { AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { splitList } from './agent-workspace-editors.ts';
+import { isValidClass, isValidScope } from './commands/recall-shared.ts';
+
+export type AgentWorkspaceEditorFieldReader = (id: string) => string;
+
+export interface AgentWorkspaceMemoryEditorResult {
+  readonly record: MemoryRecord;
+  readonly verb: 'Created' | 'Updated';
+}
+
+export interface AgentWorkspaceMemoryDeleteResult {
+  readonly id: string;
+  readonly name: string;
+}
+
+export async function submitAgentWorkspaceMemoryEditor(
+  editor: AgentWorkspaceLocalEditor,
+  memory: MemoryApi,
+  readField: AgentWorkspaceEditorFieldReader,
+): Promise<AgentWorkspaceMemoryEditorResult> {
+  if (editor.mode === 'update' && editor.recordId) {
+    const scope = parseMemoryScope(readField('scope'));
+    const summary = readField('summary');
+    const detail = readField('detail');
+    const tags = splitList(readField('tags'));
+    assertNoSecretLikeMemoryText([summary, detail, ...tags]);
+    const updated = memory.update(editor.recordId, {
+      scope,
+      summary,
+      detail: detail.length > 0 ? detail : undefined,
+      tags,
+    });
+    if (!updated) throw new Error(`Unknown Agent memory: ${editor.recordId}`);
+    return { record: updated, verb: 'Updated' };
+  }
+
+  const cls = parseMemoryClass(readField('cls'));
+  const scope = parseMemoryScope(readField('scope'));
+  const summary = readField('summary');
+  const detail = readField('detail');
+  const tags = splitList(readField('tags'));
+  const confidence = parseMemoryConfidence(readField('confidence'));
+  assertNoSecretLikeMemoryText([summary, detail, ...tags]);
+  const record = await memory.add({
+    cls,
+    scope,
+    summary,
+    detail: detail.length > 0 ? detail : undefined,
+    tags,
+    review: {
+      state: 'fresh',
+      confidence,
+    },
+  });
+  return { record, verb: 'Created' };
+}
+
+export function deleteAgentWorkspaceMemoryEditor(
+  editor: AgentWorkspaceLocalEditor,
+  confirmedId: string,
+  memory: MemoryApi,
+): AgentWorkspaceMemoryDeleteResult | null {
+  const expectedId = editor.recordId ?? '';
+  if (!expectedId || confirmedId !== expectedId) return null;
+  const removed = memory.delete(expectedId);
+  if (!removed) throw new Error(`Unknown Agent memory: ${expectedId}`);
+  return { id: expectedId, name: expectedId };
+}
+
+function parseMemoryClass(value: string): MemoryClass {
+  if (!isValidClass(value)) throw new Error(`Invalid memory class "${value}".`);
+  return value;
+}
+
+function parseMemoryScope(value: string): MemoryScope {
+  if (!isValidScope(value)) throw new Error(`Invalid memory scope "${value}".`);
+  return value;
+}
+
+function parseMemoryConfidence(value: string): number {
+  const parsed = value.trim().length === 0 ? 80 : Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) throw new Error('Memory confidence must be an integer from 0 to 100.');
+  return parsed;
+}

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

@@ -13,6 +13,8 @@ export interface AgentWorkspaceSetupChecklistInput {
   readonly model: string;
   readonly runtimeBaseUrl: string;
   readonly sessionMemoryCount: number;
+  readonly localMemoryCount: number;
+  readonly localMemoryReviewQueueCount: number;
   readonly routineCount: number;
   readonly enabledRoutineCount: number;
   readonly skillCount: number;
@@ -97,9 +99,9 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
     {
       id: 'memory',
       label: 'Local memory',
-      status: setupStatusForCount(input.sessionMemoryCount, 'ready', 'optional'),
-      detail: input.sessionMemoryCount > 0
-        ? `${input.sessionMemoryCount} session memory record(s) are available.`
+      status: setupStatusForCount(input.localMemoryCount, 'ready', 'optional'),
+      detail: input.localMemoryCount > 0
+        ? `${input.localMemoryCount} Agent memory record(s) are available; ${input.localMemoryReviewQueueCount} need review.`
         : 'Memory starts empty; durable facts should be stored deliberately and never include secrets.',
       command: '/memory',
     },

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

@@ -1,4 +1,5 @@
 import { basename, sep } from 'node:path';
+import type { MemoryRecord } from '@pellux/goodvibes-sdk/platform/state';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
@@ -113,6 +114,22 @@ function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalL
   };
 }
 
+function summarizeMemoryItem(record: MemoryRecord): AgentWorkspaceLocalLibraryItem {
+  const detail = record.detail?.trim();
+  return {
+    id: record.id,
+    name: record.summary,
+    description: detail && detail.length > 0 ? detail : `${record.scope}/${record.cls}`,
+    reviewState: record.reviewState,
+    source: 'agent-memory',
+    tags: record.tags,
+    triggers: [],
+    scope: record.scope,
+    cls: record.cls,
+    confidence: record.confidence,
+  };
+}
+
 function summarizeRuntimeProfile(profile: ReturnType<typeof listAgentRuntimeProfiles>[number]): AgentWorkspaceRuntimeProfileItem {
   return {
     id: profile.id,
@@ -154,6 +171,20 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return 0;
     }
   })();
+  const memorySnapshot = (() => {
+    try {
+      const memory = context.clients?.agentKnowledgeApi?.memory;
+      if (!memory) return { count: 0, reviewQueueCount: 0, items: [] };
+      const records = [...memory.getAll()].sort((left, right) => right.updatedAt - left.updatedAt);
+      return {
+        count: records.length,
+        reviewQueueCount: memory.reviewQueue(100).length,
+        items: records.map(summarizeMemoryItem),
+      };
+    } catch {
+      return { count: 0, reviewQueueCount: 0, items: [] };
+    }
+  })();
   const personaSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
@@ -264,6 +295,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     model,
     runtimeBaseUrl,
     sessionMemoryCount,
+    localMemoryCount: memorySnapshot.count,
+    localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
     routineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
     skillCount: skillSnapshot.count,
@@ -288,6 +321,9 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     runtimeBaseUrl,
     runtimeOwnership: 'external',
     sessionMemoryCount,
+    localMemoryCount: memorySnapshot.count,
+    localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
+    localMemories: memorySnapshot.items,
     localRoutineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
     localRoutines: routineSnapshot.items,

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

@@ -0,0 +1,51 @@
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { AgentWorkspace } from './agent-workspace.ts';
+
+export function handleAgentWorkspaceToken(
+  workspace: AgentWorkspace,
+  token: InputToken,
+  handleEscape: () => void,
+  requestRender: () => void,
+): boolean {
+  if (!workspace.active) return false;
+
+  if (workspace.localEditor) {
+    if (token.type === 'text') {
+      workspace.appendEditorText(token.value);
+    } else if (token.type === 'key') {
+      if (token.logicalName === 'escape') workspace.cancelLocalEditor();
+      else if (token.logicalName === 'enter') workspace.submitEditorFieldOrForm(requestRender);
+      else if (token.logicalName === 'tab' || token.logicalName === 'down') workspace.moveEditorField(1);
+      else if (token.logicalName === 'up') workspace.moveEditorField(-1);
+      else if (token.logicalName === 'backspace' || token.logicalName === 'delete') workspace.editorBackspace();
+      else if (token.logicalName === 'j' && token.ctrl === true) workspace.appendEditorNewline();
+    }
+    requestRender();
+    return true;
+  }
+
+  if (token.type === 'key') {
+    if (token.logicalName === 'escape') {
+      handleEscape();
+      return true;
+    }
+    if (token.logicalName === 'enter' || token.logicalName === 'space') workspace.activateSelected(requestRender);
+    else if (token.logicalName === 'left') workspace.focusCategories();
+    else if (token.logicalName === 'right') workspace.focusActions();
+    else if (token.logicalName === 'up') workspace.moveUp();
+    else if (token.logicalName === 'down') workspace.moveDown();
+    else if (token.logicalName === 'tab') workspace.toggleFocusPane();
+    else if (token.logicalName === 'home') workspace.jumpHome();
+    else if (token.logicalName === 'end') workspace.jumpEnd();
+  } else if (token.type === 'text') {
+    if (token.value === 'h') workspace.focusCategories();
+    else if (token.value === 'l') workspace.focusActions();
+    else if (token.value === 'j') workspace.moveDown();
+    else if (token.value === 'k') workspace.moveUp();
+    else if (token.value === 'r' || token.value === 'R') workspace.refreshRuntimeSnapshot();
+    else if (token.value === ' ') workspace.activateSelected(requestRender);
+  }
+
+  requestRender();
+  return true;
+}

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

@@ -8,9 +8,13 @@ export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 
 export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor' | 'local-selection' | 'local-operation';
 
-export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine' | 'profile';
+export type AgentWorkspaceLocalEditorKind = 'memory' | 'persona' | 'skill' | 'routine' | 'profile';
 
 export type AgentWorkspaceLocalOperation =
+  | 'memory-edit'
+  | 'memory-review'
+  | 'memory-stale'
+  | 'memory-delete'
   | 'persona-edit'
   | 'persona-use'
   | 'persona-review'
@@ -90,6 +94,9 @@ export interface AgentWorkspaceLocalLibraryItem {
   readonly source: string;
   readonly tags: readonly string[];
   readonly triggers: readonly string[];
+  readonly scope?: string;
+  readonly cls?: string;
+  readonly confidence?: number;
   readonly active?: boolean;
   readonly enabled?: boolean;
   readonly startCount?: number;
@@ -123,6 +130,9 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly runtimeBaseUrl: string;
   readonly runtimeOwnership: 'external';
   readonly sessionMemoryCount: number;
+  readonly localMemoryCount: number;
+  readonly localMemoryReviewQueueCount: number;
+  readonly localMemories: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localRoutineCount: number;
   readonly enabledRoutineCount: number;
   readonly localRoutines: readonly AgentWorkspaceLocalLibraryItem[];

package/src/input/agent-workspace.ts

@@ -1,12 +1,15 @@
-import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { MemoryRecord } from '@pellux/goodvibes-sdk/platform/state';
 import type { ShellPathService } from '@/runtime/index.ts';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
 import { createAgentRuntimeProfile, type AgentRuntimeProfileInfo } from '../agent/runtime-profile.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import { activateAgentWorkspaceSelection } from './agent-workspace-activation.ts';
 import { AGENT_WORKSPACE_CATEGORIES } from './agent-workspace-categories.ts';
-import { createDeleteEditor, createLocalEditor, createPersonaUpdateEditor, createProfileEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
+import { createDeleteEditor, createMemoryUpdateEditor, createPersonaUpdateEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
+import { deleteAgentWorkspaceMemoryEditor, submitAgentWorkspaceMemoryEditor } from './agent-workspace-memory-editor.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 
@@ -26,12 +29,7 @@ export type {
 } from './agent-workspace-types.ts';
 export { AGENT_WORKSPACE_MODAL_NAME } from './agent-workspace-types.ts';
 export { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
-function parseCommand(command: string): { readonly name: string; readonly args: readonly string[] } {
-  const trimmed = command.trim().replace(/^\//, '');
-  if (!trimmed) return { name: '', args: [] };
-  const parts = trimmed.split(/\s+/);
-  return { name: parts[0] ?? '', args: parts.slice(1) };
-}
+export { handleAgentWorkspaceToken } from './agent-workspace-token.ts';
 
 export class AgentWorkspace {
   public active = false;
@@ -43,6 +41,7 @@ export class AgentWorkspace {
   public lastActionResult: AgentWorkspaceActionResult | null = null;
   public localEditor: AgentWorkspaceLocalEditor | null = null;
   private readonly selectedLibraryItemIndexes: Record<AgentWorkspaceLocalEditorKind, number> = {
+    memory: 0,
     persona: 0,
     skill: 0,
     routine: 0,
@@ -207,147 +206,39 @@ export class AgentWorkspace {
     this.replaceEditorField(editor.selectedFieldIndex, characters.join(''), editor.message);
   }
 
-  submitEditorFieldOrForm(): void {
+  submitEditorFieldOrForm(requestRender?: () => void): void {
     const editor = this.localEditor;
     if (!editor) return;
     if (editor.selectedFieldIndex < editor.fields.length - 1) {
       this.moveEditorField(1);
       return;
     }
-    this.submitLocalEditor();
+    this.submitLocalEditor(requestRender);
   }
 
-  activateSelected(): void {
-    if (this.localEditor) {
-      this.submitEditorFieldOrForm();
-      return;
-    }
-    if (this.focusPane === 'categories') {
-      this.focusActions();
-      return;
-    }
-    const action = this.selectedAction;
-    if (!action) return;
-    if (action.kind === 'editor' && action.editorKind) {
-      this.localEditor = action.editorKind === 'profile'
-        ? createProfileEditor(this.runtimeSnapshot?.runtimeStarterTemplates ?? [])
-        : createLocalEditor(action.editorKind);
-      this.status = `Editing ${this.localEditor.title}.`;
-      this.lastActionResult = {
-        kind: 'guidance',
-        title: this.localEditor.title,
-        detail: this.localEditor.message,
-        safety: action.safety,
-      };
-      return;
-    }
-    if (action.kind === 'local-selection' && action.localKind) {
-      this.moveLocalLibraryItemSelection(action.localKind, action.selectionDelta ?? 0);
-      return;
-    }
-    if (action.kind === 'local-operation' && action.localOperation) {
-      this.applyLocalLibraryOperation(action.localOperation);
-      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',
-        title: action.label,
-        detail: action.detail,
-        safety: action.safety,
-      };
-      return;
-    }
-    if (action.safety === 'blocked') {
-      this.status = `Blocked here: ${action.label}.`;
-      this.lastActionResult = {
-        kind: 'blocked',
-        title: `${action.label} is blocked in Agent`,
-        detail: action.detail,
-        command: action.command,
-        safety: action.safety,
-      };
-      return;
-    }
-    const parsed = parseCommand(action.command);
-    if (!parsed.name) {
-      this.status = `No command is configured for ${action.label}.`;
-      this.lastActionResult = {
-        kind: 'error',
-        title: 'Command unavailable',
-        detail: `No command is configured for ${action.label}.`,
-        safety: action.safety,
-      };
-      return;
-    }
-    if (/<[^>\s]+(?:\s+[^>]*)?>/.test(action.command)) {
-      this.status = `Placeholder command not dispatched: ${action.command}.`;
-      this.lastActionResult = {
-        kind: 'guidance',
-        title: `${action.label} needs details`,
-        detail: 'This action is a command template. Close the workspace and run it with real task text instead of placeholder values.',
-        command: action.command,
-        safety: action.safety,
-      };
-      return;
-    }
-    if (!this.context?.executeCommand || !this.dispatchCommand) {
-      this.status = `Command dispatch is not available for ${action.command}.`;
-      this.lastActionResult = {
-        kind: 'error',
-        title: 'Command dispatch unavailable',
-        detail: `The command ${action.command} cannot be opened from this runtime.`,
-        command: action.command,
-        safety: action.safety,
-      };
-      return;
-    }
-    this.status = `Opening ${action.command}.`;
-    this.lastActionResult = {
-      kind: 'dispatched',
-      title: `Opening ${action.label}`,
-      detail: 'The workspace handed this safe or read-only command to the shell-owned command router.',
-      command: action.command,
-      safety: action.safety,
-    };
-    this.dispatchCommand(action.command);
+  activateSelected(requestRender?: () => void): void {
+    activateAgentWorkspaceSelection(this, requestRender);
   }
 
-  private clampSelection(): void {
+  hasCommandDispatch(): boolean {
+    return Boolean(this.context?.executeCommand && this.dispatchCommand);
+  }
+
+  dispatchWorkspaceCommand(command: string): void {
+    this.dispatchCommand?.(command);
+  }
+
+  clampSelection(): void {
     this.selectedCategoryIndex = Math.max(0, Math.min(this.selectedCategoryIndex, this.categories.length - 1));
     this.selectedActionIndex = Math.max(0, Math.min(this.selectedActionIndex, this.actions.length - 1));
+    this.clampLocalLibrarySelection('memory');
     this.clampLocalLibrarySelection('persona');
     this.clampLocalLibrarySelection('skill');
     this.clampLocalLibrarySelection('routine');
   }
 
   private localLibraryItems(kind: AgentWorkspaceLocalEditorKind): readonly AgentWorkspaceLocalLibraryItem[] {
+    if (kind === 'memory') return this.runtimeSnapshot?.localMemories ?? [];
     if (kind === 'persona') return this.runtimeSnapshot?.localPersonas ?? [];
     if (kind === 'skill') return this.runtimeSnapshot?.localSkills ?? [];
     if (kind === 'profile') return [];
@@ -361,7 +252,7 @@ export class AgentWorkspace {
       : Math.max(0, Math.min(this.selectedLibraryItemIndexes[kind], length - 1));
   }
 
-  private moveLocalLibraryItemSelection(kind: AgentWorkspaceLocalEditorKind, delta: number): void {
+  moveLocalLibraryItemSelection(kind: AgentWorkspaceLocalEditorKind, delta: number): void {
     const items = this.localLibraryItems(kind);
     if (items.length === 0) {
       this.status = `No local ${kind} records to select.`;
@@ -384,7 +275,7 @@ export class AgentWorkspace {
     };
   }
 
-  private applyLocalLibraryOperation(operation: AgentWorkspaceLocalOperation): void {
+  applyLocalLibraryOperation(operation: AgentWorkspaceLocalOperation): void {
     const shellPaths = this.context?.workspace?.shellPaths;
     if (!shellPaths) {
       this.status = 'Local Agent registry files are unavailable.';
@@ -412,7 +303,29 @@ export class AgentWorkspace {
         };
         return;
       }
-      if (operation === 'persona-edit') {
+      if (operation === 'memory-edit') {
+        const memory = this.memoryApi();
+        const record = memory.get(selected.id);
+        if (!record) throw new Error(`Unknown Agent memory: ${selected.id}`);
+        this.localEditor = createMemoryUpdateEditor(record);
+        this.status = `Editing memory: ${record.id}.`;
+        this.lastActionResult = {
+          kind: 'guidance',
+          title: this.localEditor.title,
+          detail: this.localEditor.message,
+          safety: 'safe',
+        };
+      } else if (operation === 'memory-review') {
+        const record = this.memoryApi().review(selected.id, { state: 'reviewed', confidence: selected.confidence ?? 100, reviewedBy: 'operator' });
+        if (!record) throw new Error(`Unknown Agent memory: ${selected.id}`);
+        this.finishLocalOperation('memory', `Reviewed memory ${record.id}`, `${record.summary} is marked reviewed.`);
+      } else if (operation === 'memory-stale') {
+        const record = this.memoryApi().review(selected.id, { state: 'stale', staleReason: 'Marked stale from Agent workspace', reviewedBy: 'operator' });
+        if (!record) throw new Error(`Unknown Agent memory: ${selected.id}`);
+        this.finishLocalOperation('memory', `Marked memory stale ${record.id}`, `${record.summary} needs review before reuse.`);
+      } else if (operation === 'memory-delete') {
+        this.openDeleteEditor('memory', selected);
+      } else if (operation === 'persona-edit') {
         const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
         const persona = registry.get(selected.id);
         if (!persona) throw new Error(`Unknown persona: ${selected.id}`);
@@ -492,11 +405,18 @@ export class AgentWorkspace {
   }
 
   private selectedItemForOperation(operation: AgentWorkspaceLocalOperation): AgentWorkspaceLocalLibraryItem | null {
+    if (operation.startsWith('memory-')) return this.selectedLocalLibraryItem('memory');
     if (operation.startsWith('persona-')) return this.selectedLocalLibraryItem('persona');
     if (operation.startsWith('skill-')) return this.selectedLocalLibraryItem('skill');
     return this.selectedLocalLibraryItem('routine');
   }
 
+  private memoryApi(): MemoryApi {
+    const memory = this.context?.clients?.agentKnowledgeApi?.memory;
+    if (!memory) throw new Error('Agent Memory API is unavailable; refusing default Knowledge/Wiki or non-Agent fallback.');
+    return memory;
+  }
+
   private finishLocalOperation(kind: AgentWorkspaceLocalEditorKind, title: string, detail: string): void {
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
     this.clampLocalLibrarySelection(kind);
@@ -538,7 +458,7 @@ export class AgentWorkspace {
     return editor.fields.find((field) => field.required && field.value.trim().length === 0) ?? null;
   }
 
-  private submitLocalEditor(): void {
+  private submitLocalEditor(requestRender?: () => void): void {
     const editor = this.localEditor;
     if (!editor) return;
     const missing = this.missingEditorField();
@@ -552,6 +472,26 @@ export class AgentWorkspace {
       this.status = `${missing.label} is required.`;
       return;
     }
+    if (editor.kind === 'memory') {
+      if (editor.mode === 'delete') {
+        try {
+          this.submitMemoryDeleteEditor(editor);
+        } catch (error) {
+          const detail = error instanceof Error ? error.message : String(error);
+          this.localEditor = { ...editor, message: detail };
+          this.status = detail;
+          this.lastActionResult = {
+            kind: 'error',
+            title: `${editor.title} failed`,
+            detail,
+          };
+        }
+        requestRender?.();
+        return;
+      }
+      void this.submitMemoryEditor(editor).finally(() => requestRender?.());
+      return;
+    }
     const shellPaths = this.context?.workspace?.shellPaths;
     if (!shellPaths) {
       this.localEditor = { ...editor, message: 'Cannot save because Agent shell paths are unavailable.' };
@@ -679,7 +619,11 @@ export class AgentWorkspace {
       this.status = 'Deletion not confirmed.';
       return;
     }
-    if (editor.kind === 'persona') {
+    if (editor.kind === 'memory') {
+      const removed = this.memoryApi().delete(expectedId);
+      if (!removed) throw new Error(`Unknown Agent memory: ${expectedId}`);
+      this.finishLocalDelete(editor.kind, expectedId, expectedId);
+    } else if (editor.kind === 'persona') {
       const removed = AgentPersonaRegistry.fromShellPaths(shellPaths).deletePersona(expectedId);
       this.finishLocalDelete(editor.kind, removed.id, removed.name);
     } else if (editor.kind === 'skill') {
@@ -691,6 +635,56 @@ export class AgentWorkspace {
     }
   }
 
+  private submitMemoryDeleteEditor(editor: AgentWorkspaceLocalEditor): void {
+    const expectedId = editor.recordId ?? '';
+    const confirmedId = this.editorField('confirm');
+    const removed = deleteAgentWorkspaceMemoryEditor(editor, confirmedId, this.memoryApi());
+    if (!removed) {
+      this.localEditor = {
+        ...editor,
+        message: `Deletion not confirmed. Type ${expectedId} exactly, then press Enter.`,
+      };
+      this.status = 'Deletion not confirmed.';
+      return;
+    }
+    this.finishLocalDelete(editor.kind, removed.id, removed.name);
+  }
+
+  private async submitMemoryEditor(editor: AgentWorkspaceLocalEditor): Promise<void> {
+    try {
+      this.status = 'Saving Agent memory...';
+      const result = await submitAgentWorkspaceMemoryEditor(editor, this.memoryApi(), (id) => this.editorField(id));
+      this.finishMemoryEditor(result.record, result.verb);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      this.localEditor = { ...editor, message: detail };
+      this.status = detail;
+      this.lastActionResult = {
+        kind: 'error',
+        title: `${editor.title} failed`,
+        detail,
+      };
+    }
+  }
+
+  private finishMemoryEditor(record: MemoryRecord, verb: 'Created' | 'Updated'): void {
+    this.localEditor = null;
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    const categoryIndex = this.categories.findIndex((category) => category.id === 'memory');
+    if (categoryIndex >= 0) {
+      this.selectedCategoryIndex = categoryIndex;
+      this.selectedActionIndex = 0;
+    }
+    this.status = `${verb} memory: ${record.summary}.`;
+    this.lastActionResult = {
+      kind: 'refreshed',
+      title: `${verb} memory`,
+      detail: `${record.summary} (${record.id}) was saved to Agent-owned memory only.`,
+      safety: 'safe',
+    };
+    this.clampSelection();
+  }
+
   private finishLocalEditor(kind: AgentWorkspaceLocalEditorKind, id: string, name: string, verb: 'Created' | 'Updated'): void {
     this.localEditor = null;
     const categoryId = editorCategoryId(kind);
@@ -749,52 +743,3 @@ export class AgentWorkspace {
     this.clampSelection();
   }
 }
-
-export function handleAgentWorkspaceToken(
-  workspace: AgentWorkspace,
-  token: InputToken,
-  handleEscape: () => void,
-  requestRender: () => void,
-): boolean {
-  if (!workspace.active) return false;
-
-  if (workspace.localEditor) {
-    if (token.type === 'text') {
-      workspace.appendEditorText(token.value);
-    } else if (token.type === 'key') {
-      if (token.logicalName === 'escape') workspace.cancelLocalEditor();
-      else if (token.logicalName === 'enter') workspace.submitEditorFieldOrForm();
-      else if (token.logicalName === 'tab' || token.logicalName === 'down') workspace.moveEditorField(1);
-      else if (token.logicalName === 'up') workspace.moveEditorField(-1);
-      else if (token.logicalName === 'backspace' || token.logicalName === 'delete') workspace.editorBackspace();
-      else if (token.logicalName === 'j' && token.ctrl === true) workspace.appendEditorNewline();
-    }
-    requestRender();
-    return true;
-  }
-
-  if (token.type === 'key') {
-    if (token.logicalName === 'escape') {
-      handleEscape();
-      return true;
-    }
-    if (token.logicalName === 'enter' || token.logicalName === 'space') workspace.activateSelected();
-    else if (token.logicalName === 'left') workspace.focusCategories();
-    else if (token.logicalName === 'right') workspace.focusActions();
-    else if (token.logicalName === 'up') workspace.moveUp();
-    else if (token.logicalName === 'down') workspace.moveDown();
-    else if (token.logicalName === 'tab') workspace.toggleFocusPane();
-    else if (token.logicalName === 'home') workspace.jumpHome();
-    else if (token.logicalName === 'end') workspace.jumpEnd();
-  } else if (token.type === 'text') {
-    if (token.value === 'h') workspace.focusCategories();
-    else if (token.value === 'l') workspace.focusActions();
-    else if (token.value === 'j') workspace.moveDown();
-    else if (token.value === 'k') workspace.moveUp();
-    else if (token.value === 'r' || token.value === 'R') workspace.refreshRuntimeSnapshot();
-    else if (token.value === ' ') workspace.activateSelected();
-  }
-
-  requestRender();
-  return true;
-}

package/src/panels/builtin/usage.ts

@@ -0,0 +1,21 @@
+import type { PanelManager } from '../panel-manager.ts';
+import { CostTrackerPanel } from '../cost-tracker-panel.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+import { requireUiServices } from './shared.ts';
+
+export function registerUsagePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  if (!deps.getOrchestratorUsage) return;
+
+  const { getOrchestratorUsage, budgetThreshold } = deps;
+  manager.registerType({
+    id: 'cost',
+    name: 'Cost',
+    icon: '$',
+    category: 'monitoring',
+    description: 'Estimated assistant usage costs for this session and explicit delegated work, with budget alerts',
+    factory: () => {
+      const ui = requireUiServices(deps);
+      return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage, { budgetThreshold });
+    },
+  });
+}

package/src/panels/builtin-panels.ts

@@ -1,6 +1,6 @@
 import type { PanelManager } from './panel-manager.ts';
 import { resolveBuiltinPanelDeps, type BuiltinPanelDeps } from './builtin/shared.ts';
-import { registerDevelopmentPanels } from './builtin/development.ts';
+import { registerUsagePanels } from './builtin/usage.ts';
 import { registerOperationsPanels } from './builtin/operations.ts';
 import { registerAgentPanels } from './builtin/agent.ts';
 import { registerSessionPanels } from './builtin/session.ts';
@@ -13,7 +13,7 @@ import { registerKnowledgePanels } from './builtin/knowledge.ts';
  */
 export function registerBuiltinPanels(manager: PanelManager, deps: BuiltinPanelDeps): void {
   const resolved = resolveBuiltinPanelDeps(deps);
-  registerDevelopmentPanels(manager, resolved);
+  registerUsagePanels(manager, resolved);
   registerOperationsPanels(manager, resolved);
   registerAgentPanels(manager, resolved);
   registerSessionPanels(manager, resolved);

package/src/panels/panel-list-panel.ts

@@ -65,9 +65,8 @@ const C = {
   intro:       '#94a3b8',
 } as const;
 
-const CATEGORY_ORDER: PanelCategory[] = ['development', 'agent', 'monitoring', 'session', 'ai'];
+const CATEGORY_ORDER: PanelCategory[] = ['agent', 'monitoring', 'session', 'ai'];
 const CATEGORY_LABELS: Record<PanelCategory, string> = {
-  development: 'Development',
   agent:       'Agent',
   monitoring:  'Monitoring',
   session:     'Session',

package/src/panels/panel-picker.ts

@@ -1,11 +1,10 @@
 import type { PanelRegistration, PanelCategory } from './types.ts';
 
 /** Display order for panel categories. */
-const CATEGORY_ORDER: PanelCategory[] = ['development', 'agent', 'monitoring', 'session', 'ai'];
+const CATEGORY_ORDER: PanelCategory[] = ['agent', 'monitoring', 'session', 'ai'];
 
 /** Human-readable labels for each category. */
 const CATEGORY_LABELS: Record<PanelCategory, string> = {
-  development: 'Development',
   agent:       'Agent',
   monitoring:  'Monitoring',
   session:     'Session',

package/src/panels/types.ts

@@ -1,7 +1,7 @@
 import type { Line } from '../types/grid.ts';
 import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
 
-export type PanelCategory = 'development' | 'agent' | 'monitoring' | 'session' | 'ai';
+export type PanelCategory = 'agent' | 'monitoring' | 'session' | 'ai';
 
 export interface Panel {
   id: string;

package/src/renderer/agent-workspace.ts

@@ -123,6 +123,8 @@ function localLibraryLines(
       selected ? 'selected' : '',
       item.active ? 'active' : '',
       item.enabled === true ? 'enabled' : item.enabled === false ? 'disabled' : '',
+      item.scope && item.cls ? `${item.scope}/${item.cls}` : '',
+      item.confidence !== undefined ? `${item.confidence}%` : '',
       item.reviewState,
       item.startCount !== undefined ? `starts ${item.startCount}` : '',
     ].filter(Boolean).join(' / ');
@@ -301,11 +303,14 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
   } else if (category.id === 'memory') {
     base.push(
       { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
+      { text: `Agent memory: ${snapshot.localMemoryCount}; review queue: ${snapshot.localMemoryReviewQueueCount}`, fg: PALETTE.info },
       { text: `Local routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
       { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}; bundles: ${snapshot.localSkillBundleCount}; active skills: ${snapshot.activeSkillCount}`, fg: PALETTE.info },
       { text: `Local personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
       { 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 },
+      { text: '' },
+      ...localLibraryLines('Agent Memory', snapshot.localMemories, 'No Agent memory yet. Create one here with Create memory.', workspace.selectedLocalLibraryItem('memory')?.id ?? null),
     );
   } else if (category.id === 'personas') {
     base.push(

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

package/src/panels/builtin/development.ts

@@ -1,31 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { PlanDashboardPanel } from '../plan-dashboard-panel.ts';
-import { CostTrackerPanel } from '../cost-tracker-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireUiServices } from './shared.ts';
-
-export function registerDevelopmentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  manager.registerType({
-    id: 'plan',
-    name: 'Plan',
-    icon: 'P',
-    category: 'agent',
-    description: 'Active execution plan with phase progress and item status',
-    factory: () => new PlanDashboardPanel(deps.planManager),
-  });
-
-  if (deps.getOrchestratorUsage) {
-    const { getOrchestratorUsage, budgetThreshold } = deps;
-    manager.registerType({
-      id: 'cost',
-      name: 'Cost',
-      icon: '$',
-      category: 'monitoring',
-      description: 'Estimated costs per session, agent, and plan with budget alerts',
-      factory: () => {
-        const ui = requireUiServices(deps);
-        return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage, { budgetThreshold });
-      },
-    });
-  }
-}