@pellux/goodvibes-agent 0.1.102 → 0.1.104

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

@@ -11,8 +11,10 @@ export interface AgentWorkspaceSetupChecklistItem {
 export interface AgentWorkspaceSetupChecklistInput {
   readonly provider: string;
   readonly model: string;
-  readonly daemonBaseUrl: string;
+  readonly runtimeBaseUrl: string;
   readonly sessionMemoryCount: number;
+  readonly localMemoryCount: number;
+  readonly localMemoryReviewQueueCount: number;
   readonly routineCount: number;
   readonly enabledRoutineCount: number;
   readonly skillCount: number;
@@ -39,7 +41,7 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
       id: 'runtime',
       label: 'GoodVibes runtime',
       status: 'ready',
-      detail: `Agent will connect to ${input.daemonBaseUrl}; runtime ownership stays outside this product.`,
+      detail: `Agent will connect to ${input.runtimeBaseUrl}; runtime ownership stays outside this product.`,
       command: '/health',
     },
     {
@@ -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;
@@ -252,7 +283,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const ttsVoice = readConfigString(context, 'tts.voice', '(voice default)');
   const ttsLlmProvider = readConfigString(context, 'tts.llmProvider', '');
   const ttsLlmModel = readConfigString(context, 'tts.llmModel', '');
-  const daemonBaseUrl = `http://${host}:${port}`;
+  const runtimeBaseUrl = `http://${host}:${port}`;
   const channels = buildAgentWorkspaceChannels(context);
   const voiceMediaReadiness = buildAgentWorkspaceVoiceMediaReadiness({
     context,
@@ -262,8 +293,10 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const setupChecklist = buildAgentWorkspaceSetupChecklist({
     provider,
     model,
-    daemonBaseUrl,
+    runtimeBaseUrl,
     sessionMemoryCount,
+    localMemoryCount: memorySnapshot.count,
+    localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
     routineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
     skillCount: skillSnapshot.count,
@@ -285,9 +318,12 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     sessionId: context.session?.runtime?.sessionId ?? 'unknown',
     workingDirectory: context.workspace?.shellPaths?.workingDirectory ?? 'unavailable',
     homeDirectory: context.workspace?.shellPaths?.homeDirectory ?? 'unavailable',
-    daemonBaseUrl,
-    daemonOwnership: 'external',
+    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;
@@ -120,9 +127,12 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly sessionId: string;
   readonly workingDirectory: string;
   readonly homeDirectory: string;
-  readonly daemonBaseUrl: string;
-  readonly daemonOwnership: 'external';
+  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[];