@pellux/goodvibes-agent 0.1.117 → 1.0.0

package/src/input/commands/schedule-runtime.ts

@@ -8,7 +8,7 @@ import {
   buildReminderSchedulePreview,
   createReminderSchedule,
   parseReminderScheduleArgs,
-  resolveReminderDaemonConnection,
+  resolveReminderConnectedHostConnection,
 } from '../../agent/reminder-schedule.ts';
 import {
   formatReminderScheduleFailure,
@@ -18,8 +18,8 @@ import {
 import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
-  promoteRoutineToDaemonSchedule,
-  resolveAgentDaemonConnection,
+  promoteRoutineToConnectedSchedule,
+  resolveAgentConnectedHostConnection,
 } from '../../agent/routine-schedule-promotion.ts';
 import { parseRoutineSchedulePromotionArgs } from '../../agent/routine-schedule-args.ts';
 import {
@@ -36,6 +36,7 @@ import {
 } from '../../agent/routine-schedule-receipts.ts';
 import type { CommandContext } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
+import { executeConfirmedOperatorAction } from './operator-actions-runtime.ts';
 
 function formatSchedule(schedule: AutomationScheduleDefinition): string {
   switch (schedule.kind) {
@@ -64,10 +65,11 @@ function formatPrompt(job: AutomationJob): string {
 function printReadOnlyScheduleBoundary(print: (text: string) => void, requestedAction: string): void {
   print([
     'GoodVibes Agent local schedule commands are read-only in this runtime.',
-    `  requested: ${requestedAction}`,
-    '  policy: no local Agent automation jobs, scheduled spawns, or immediate automation runs',
-    '  use: /schedule list',
-    '  schedule route: use /schedule promote-routine <routine> --cron <expr> --yes to create a connected schedule explicitly',
+    `  requested ${requestedAction}`,
+    '  policy no hidden local Agent automation jobs or immediate automation runs',
+    '  use /schedule list',
+    '  connected run route /automation schedule run <schedule-id> --yes',
+    '  schedule route use /schedule promote-routine <routine> --cron <expr> --yes to create a connected schedule explicitly',
   ].join('\n'));
 }
 
@@ -83,7 +85,7 @@ async function promoteRoutineSchedule(args: readonly string[], ctx: CommandConte
   const shellPaths = requireShellPaths(ctx);
   const routine = AgentRoutineRegistry.fromShellPaths(shellPaths).get(parsed.routineId ?? '');
   if (!routine) {
-    ctx.print(`Unknown Agent routine: ${parsed.routineId ?? ''}`);
+    ctx.print(`Unknown Agent routine ${parsed.routineId ?? ''}`);
     return;
   }
   const preview = buildRoutineSchedulePreview(routine, parsed);
@@ -91,8 +93,8 @@ async function promoteRoutineSchedule(args: readonly string[], ctx: CommandConte
     ctx.print(formatRoutineSchedulePreview(preview));
     return;
   }
-  const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
-  const result = await promoteRoutineToDaemonSchedule(connection, preview);
+  const connection = resolveAgentConnectedHostConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const result = await promoteRoutineToConnectedSchedule(connection, preview);
   const receipt = RoutineScheduleReceiptStore.fromShellPaths(shellPaths).append(connection, preview, result);
   ctx.print(result.ok ? `${formatRoutineScheduleSuccess(result)}\n  receipt: ${receipt.id}` : `${formatRoutineScheduleFailure(result)}\n  receipt: ${receipt.id}`);
 }
@@ -112,7 +114,7 @@ async function createReminder(args: readonly string[], ctx: CommandContext): Pro
     return;
   }
   const shellPaths = requireShellPaths(ctx);
-  const connection = resolveReminderDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const connection = resolveReminderConnectedHostConnection(ctx.platform.configManager, shellPaths.homeDirectory);
   const result = await createReminderSchedule(connection, preview);
   ctx.print(result.ok ? formatReminderScheduleSuccess(result) : formatReminderScheduleFailure(result));
 }
@@ -121,7 +123,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'schedule',
     aliases: ['sched'],
-    description: 'Inspect schedules, create confirmed reminders, and explicitly promote local Agent routines to connected schedules',
+    description: 'Inspect schedules, create confirmed reminders, and explicitly promote Agent-local routines to connected schedules',
     usage: 'list | remind --at <iso> --message <text> --yes | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-channel slack] --yes',
     argsHint: 'list | remind --at <iso> --message <text> --yes | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-channel slack] --yes',
     async handler(args, ctx) {
@@ -144,7 +146,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
 
       if (sub === 'reconcile' || sub === 'sync' || sub === 'status') {
         const shellPaths = requireShellPaths(ctx);
-        const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+        const connection = resolveAgentConnectedHostConnection(ctx.platform.configManager, shellPaths.homeDirectory);
         const result = await reconcileRoutineScheduleReceipts(connection, RoutineScheduleReceiptStore.fromShellPaths(shellPaths).snapshot());
         ctx.print(formatRoutineScheduleCorrelation(result));
         return;
@@ -157,7 +159,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         const receipt = RoutineScheduleReceiptStore.fromShellPaths(requireShellPaths(ctx)).get(id);
-        ctx.print(receipt ? formatRoutineScheduleReceipt(receipt) : `Unknown routine schedule receipt: ${id}`);
+        ctx.print(receipt ? formatRoutineScheduleReceipt(receipt) : `Unknown routine schedule receipt ${id}`);
         return;
       }
 
@@ -176,20 +178,30 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
           );
           return;
         }
-        const lines = ['Automation jobs:', ''];
+        const lines = ['Automation jobs', ''];
         for (const job of jobs) {
           const status = job.enabled ? '● enabled ' : '○ paused  ';
           const next = formatNextRun(job.nextRunAt);
           const last = job.lastRunAt ? new Date(job.lastRunAt).toLocaleString() : 'never';
-          lines.push(`  ${job.id.slice(0, 12)}  ${status} runs:${job.runCount}  next:${next}  last:${last}`);
-          lines.push(`    name: ${job.name}  schedule: ${formatSchedule(job.schedule)}`);
-          lines.push(`    prompt: ${formatPrompt(job)}`);
+          lines.push(`  ${job.id.slice(0, 12)}  ${status} runs ${job.runCount}  next ${next}  last ${last}`);
+          lines.push(`    name ${job.name}  schedule ${formatSchedule(job.schedule)}`);
+          lines.push(`    prompt ${formatPrompt(job)}`);
         }
         ctx.print(lines.join('\n'));
         return;
       }
 
-      if (sub === 'add' || sub === 'remove' || sub === 'enable' || sub === 'disable' || sub === 'run') {
+      if (sub === 'run') {
+        const scheduleId = args[1] ?? '';
+        if (!scheduleId) {
+          ctx.print('Usage: /schedule run <schedule-id> --yes');
+          return;
+        }
+        await executeConfirmedOperatorAction(ctx, 'schedules.run', 'scheduleId', scheduleId, args.slice(2), '/schedule run <schedule-id> --yes');
+        return;
+      }
+
+      if (sub === 'add' || sub === 'remove' || sub === 'enable' || sub === 'disable') {
         printReadOnlyScheduleBoundary(ctx.print, `/schedule ${args.join(' ')}`.trim());
         return;
       }
@@ -200,9 +212,10 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         + '  /schedule receipts\n'
         + '  /schedule reconcile\n'
         + '  /schedule receipt <receipt-id>\n'
+        + '  /schedule run <schedule-id> --yes\n'
         + '  /schedule remind (--cron <expr>|--every <interval>|--at <iso-time>) (--message <text>|<text...>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes\n'
         + '  /schedule promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes\n'
-        + '  Local schedule mutations and runs remain blocked.'
+        + '  Local schedule mutations remain blocked; schedule run is a confirmed connected-host action.'
       );
     },
   });

package/src/input/commands/security-runtime.ts

@@ -12,7 +12,7 @@ export function registerSecurityRuntimeCommands(registry: CommandRegistry): void
     handler(args, ctx) {
       const subcommand = args[0]?.toLowerCase() ?? 'review';
       if (subcommand === 'open' || subcommand === 'panel') {
-        ctx.print('Security panels are not part of the Agent workspace. Use /security review.');
+        ctx.print('Open Agent Workspace -> Tools & MCP -> Security review for the workspace view, or run /security review for compact command output.');
         return;
       }
       const audit = requireTokenAuditor(ctx).auditAll(Date.now());
@@ -29,13 +29,13 @@ export function registerSecurityRuntimeCommands(registry: CommandRegistry): void
 
       if (subcommand === 'tokens') {
         if (audit.results.length === 0) {
-          ctx.print('No registered API tokens are currently under audit.');
+          ctx.print('No registered API tokens are currently available for security review.');
           return;
         }
         ctx.print([
-          `Token Audit (${audit.results.length})`,
+          `Token Review (${audit.results.length})`,
           ...audit.results.map((result) => (
-            `  ${result.label}  policy=${result.scope.policyId}  scope=${result.scope.outcome}  rotation=${result.rotation.outcome}  blocked=${result.blocked ? 'yes' : 'no'}`
+            `  ${result.label}  policy ${result.scope.policyId}  scope ${result.scope.outcome}  rotation ${result.rotation.outcome}  blocked ${result.blocked ? 'yes' : 'no'}`
           )),
         ].join('\n'));
         return;

package/src/input/commands/session-content.ts

@@ -1,12 +1,43 @@
 import { join, resolve } from 'path';
 import { existsSync, mkdirSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import type { CommandRegistry } from '../command-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import type { SelectionItem } from '../selection-modal.ts';
-import { exportToMarkdown } from '@pellux/goodvibes-sdk/platform/export';
-import { requireSessionManager, requireSessionMemoryStore, requireShellPaths } from './runtime-services.ts';
+import type { SessionMeta } from '@pellux/goodvibes-sdk/platform/sessions';
+import { exportToMarkdown, extractText } from '@pellux/goodvibes-sdk/platform/export';
+import { requireSessionManager, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import { readConversationMessageSnapshots } from '../../core/conversation-message-snapshot.ts';
+
+function formatSessionFailure(action: string, error: unknown): string {
+  return [
+    `Failed to ${action}`,
+    `  error ${summarizeError(error)}`,
+  ].join('\n');
+}
+
+type ConversationSnapshotReader = {
+  readonly getMessageSnapshot?: () => ReturnType<typeof readConversationMessageSnapshots>;
+  readonly toJSON?: () => unknown;
+};
+
+function isObjectArray(value: unknown): value is readonly object[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === 'object' && entry !== null);
+}
+
+function getCurrentConversationMessages(ctx: CommandContext): ReturnType<typeof readConversationMessageSnapshots> {
+  const manager = ctx.session.conversationManager as unknown as ConversationSnapshotReader;
+  if (typeof manager.getMessageSnapshot === 'function') return manager.getMessageSnapshot();
+  if (typeof manager.toJSON === 'function') {
+    const serialized = manager.toJSON();
+    if (serialized && typeof serialized === 'object' && 'messages' in serialized) {
+      const messages = (serialized as { readonly messages?: unknown }).messages;
+      if (isObjectArray(messages)) return readConversationMessageSnapshots(messages);
+    }
+  }
+  throw new Error('Conversation manager cannot export message snapshots.');
+}
 
 export function registerSessionContentCommands(registry: CommandRegistry): void {
   registry.register({
@@ -32,7 +63,10 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       }
       const resolvedPath = shellPaths.resolveWorkspacePath(outPath);
       if (!shellPaths.isWithinWorkingDirectory(resolvedPath)) {
-        ctx.print('Error: Export path must be within the current directory.');
+        ctx.print([
+          'Error',
+          '  message Export path must be within the current directory.',
+        ].join('\n'));
         return;
       }
       if (!yes) {
@@ -41,23 +75,10 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       }
 
       try {
-        const data = ctx.session.conversationManager.toJSON() as { messages: Array<Record<string, unknown>> };
-        const msgs = data.messages ?? [];
+        const msgs = getCurrentConversationMessages(ctx);
         let fileContent: string;
         if (format === 'markdown') {
-          const exportMsgs = msgs.map(m => ({
-            role: String(m.role ?? 'user') as 'user' | 'assistant' | 'system' | 'tool',
-            content: Array.isArray(m.content)
-              ? m.content as import('@pellux/goodvibes-sdk/platform/providers').ContentPart[]
-              : String(m.content ?? ''),
-            toolCalls: m.toolCalls as import('@pellux/goodvibes-sdk/platform/types').ToolCall[] | undefined,
-            callId: m.callId as string | undefined,
-            toolName: m.toolName as string | undefined,
-            reasoningContent: m.reasoningContent as string | undefined,
-            reasoningSummary: m.reasoningSummary as string | undefined,
-            usage: m.usage as { inputTokens: number; outputTokens: number; cacheReadTokens?: number; cacheWriteTokens?: number } | undefined,
-          }));
-          fileContent = exportToMarkdown(exportMsgs, {
+          fileContent = exportToMarkdown(msgs, {
             model: ctx.session.runtime.model,
             provider: ctx.session.runtime.provider,
             sessionId: ctx.session.runtime.sessionId,
@@ -66,8 +87,8 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         } else {
           const lines: string[] = [];
           for (const m of msgs) {
-            const role = String(m.role ?? 'unknown').toUpperCase();
-            const content = typeof m.content === 'string' ? m.content : '';
+            const role = m.role.toUpperCase();
+            const content = extractText(m.content);
             if (!content.trim()) continue;
             lines.push(`[${role}]`);
             lines.push(content);
@@ -79,9 +100,13 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         const dir = dirname(resolvedPath);
         if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
         await writeFile(resolvedPath, fileContent, 'utf-8');
-        ctx.print(`Exported ${msgs.length} messages to: ${resolvedPath}`);
+        ctx.print([
+          'Exported conversation',
+          `  messages ${msgs.length}`,
+          `  path ${resolvedPath}`,
+        ].join('\n'));
       } catch (err) {
-        ctx.print(`Export failed: ${summarizeError(err)}`);
+        ctx.print(formatSessionFailure('export conversation', err));
       }
     },
   });
@@ -92,10 +117,13 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     usage: '[text]',
     argsHint: '[text]',
     handler(args, ctx) {
-      if (args.length === 0) ctx.print(ctx.session.conversationManager.title ? `Conversation title: ${ctx.session.conversationManager.title}` : 'No title set.');
+      if (args.length === 0) ctx.print(ctx.session.conversationManager.title ? `Conversation title\n  title ${ctx.session.conversationManager.title}` : 'No title set.');
       else {
         ctx.session.conversationManager.title = args.join(' ');
-        ctx.print(`Title set to: ${ctx.session.conversationManager.title}`);
+        ctx.print([
+          'Title set',
+          `  title ${ctx.session.conversationManager.title}`,
+        ].join('\n'));
         ctx.renderRequest();
       }
     },
@@ -109,19 +137,24 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     handler(args, ctx) {
       const sessionManager = requireSessionManager(ctx);
       const rawName = args[0] || ctx.session.conversationManager.title || `session-${Date.now()}`;
-      const exportData = ctx.session.conversationManager.toJSON() as { messages: object[] };
-      const messages = exportData.messages ?? [];
-      const meta = {
+      const messages = ctx.session.conversationManager.getMessageSnapshot();
+      const meta: SessionMeta = {
         title: ctx.session.conversationManager.title,
         model: ctx.session.runtime.model,
         provider: ctx.session.runtime.provider,
         timestamp: Date.now(),
+        titleSource: ctx.session.conversationManager.getTitleSource(),
       };
       try {
         const { filePath, sanitizedName } = sessionManager.save(rawName, messages, meta);
-        ctx.print(`Session saved: ${rawName}${sanitizedName !== rawName ? ` (saved as "${sanitizedName}")` : ''}\n  → ${filePath}`);
+        ctx.print([
+          'Session saved',
+          `  name ${rawName}`,
+          ...(sanitizedName !== rawName ? [`  saved as ${sanitizedName}`] : []),
+          `  path ${filePath}`,
+        ].join('\n'));
       } catch (e) {
-        ctx.print(`Failed to save session: ${summarizeError(e)}`);
+        ctx.print(formatSessionFailure('save session', e));
       }
     },
   });
@@ -140,13 +173,18 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       try {
         const { meta, messages, agentRecords } = sessionManager.load(args[0]);
         ctx.session.conversationManager.resetAll();
-        ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
+        ctx.session.conversationManager.fromJSON({ messages: readConversationMessageSnapshots(messages) });
         if (meta.title) ctx.session.conversationManager.title = meta.title;
         ctx.session.conversationManager.rebuildHistory();
         ctx.renderRequest();
-        ctx.print(`Session loaded: ${args[0]} (${messages.length} messages)${agentRecords.length > 0 ? ` [ignored ${agentRecords.length} host-owned local agent record${agentRecords.length !== 1 ? 's' : ''}]` : ''}`);
+        ctx.print([
+          'Session loaded',
+          `  id ${args[0]}`,
+          `  messages ${messages.length}`,
+          ...(agentRecords.length > 0 ? [`  ignored connected-host records ${agentRecords.length}`] : []),
+        ].join('\n'));
       } catch (e) {
-        ctx.print(`Failed to load session: ${summarizeError(e)}`);
+        ctx.print(formatSessionFailure('load session', e));
       }
     },
   });
@@ -217,67 +255,31 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       const sessions = sessionManager.list();
       if (ctx.openSelection) {
         const items: SelectionItem[] = sessions.length === 0
-          ? [{ id: '_empty', label: 'No saved sessions', detail: 'Use /save [name] to save' }]
+          ? [{ id: '_empty', label: 'No saved sessions', detail: 'Open Agent Workspace -> Conversation -> Save current session' }]
           : sessions.map(s => ({ id: s.name, label: s.name, detail: s.title || '(untitled)', actions: 'Enter to load' }));
         ctx.openSelection('Sessions', items, { allowSearch: true }, (result) => {
           if (!result) return;
           try {
             const { meta, messages } = sessionManager.load(result.item.id);
             ctx.session.conversationManager.resetAll();
-            ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
+            ctx.session.conversationManager.fromJSON({ messages: readConversationMessageSnapshots(messages) });
             if (meta.title) ctx.session.conversationManager.title = meta.title;
             ctx.session.conversationManager.rebuildHistory();
             ctx.renderRequest();
-            ctx.print(`Session loaded: ${result.item.id} (${messages.length} messages)`);
+            ctx.print([
+              'Session loaded',
+              `  id ${result.item.id}`,
+              `  messages ${messages.length}`,
+            ].join('\n'));
           } catch (e) {
-            ctx.print(`Failed to load session: ${summarizeError(e)}`);
+            ctx.print(formatSessionFailure('load session', e));
           }
         });
         return;
       }
-      const lines = ['Saved sessions:', ''];
+      const lines = ['Saved sessions', ''];
       for (const s of sessions) lines.push(`  ${s.name.padEnd(30)} ${(s.title || '(untitled)').padEnd(24)} ${new Date(s.timestamp).toLocaleString()}  (${s.messageCount} msgs)`);
       ctx.print(lines.join('\n'));
     },
   });
-
-  registry.register({
-    name: 'session-memory',
-    aliases: ['smemory'],
-    description: 'Manage conversation-pinned memories used during context compaction',
-    usage: '[list|add <text>|remove <id> --yes]',
-    argsHint: '[list|add|remove]',
-    handler(args, ctx) {
-      const sub = args[0] ?? 'list';
-      if (sub === 'list' || args.length === 0) {
-        const memories = requireSessionMemoryStore(ctx).list();
-        ctx.print(memories.length === 0
-          ? 'No conversation-pinned memories. Use !# prefix or /session-memory add <text> to create one.'
-          : [`Conversation-Pinned Memories (${memories.length}):`, ...memories.map(m => `  [${m.id}] ${m.text}`)].join('\n'));
-      } else if (sub === 'add') {
-        const text = args.slice(1).join(' ').trim();
-        if (!text) {
-          ctx.print('Usage: /session-memory add <text>');
-          return;
-        }
-        const id = requireSessionMemoryStore(ctx).add(text);
-        ctx.print(`Memory added: [${id}] ${text}`);
-      } else if (sub === 'remove') {
-        const parsed = stripYesFlag(args);
-        const id = parsed.rest[1];
-        if (!id) {
-          ctx.print('Usage: /session-memory remove <id> --yes');
-          return;
-        }
-        if (!parsed.yes) {
-          requireYesFlag(ctx, `remove conversation-pinned memory ${id}`, '/session-memory remove <id> --yes');
-          return;
-        }
-        const store = requireSessionMemoryStore(ctx);
-        ctx.print(store.remove(id) ? `Memory removed: [${id}]` : `Memory not found: ${id}`);
-      } else {
-        ctx.print('Usage: /session-memory [list|add <text>|remove <id> --yes]\n  /session-memory                    — list conversation-pinned memories\n  /session-memory list               — list conversation-pinned memories\n  /session-memory add <text>         — add a memory without sending a message\n  /session-memory remove <id> --yes  — remove a specific memory');
-      }
-    },
-  });
 }