@pellux/goodvibes-agent 0.1.6 → 0.1.8

package/src/input/agent-workspace.ts

@@ -1,6 +1,7 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
@@ -53,6 +54,8 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly daemonBaseUrl: string;
   readonly daemonOwnership: 'external';
   readonly sessionMemoryCount: number;
+  readonly localRoutineCount: number;
+  readonly enabledRoutineCount: number;
   readonly localSkillCount: number;
   readonly enabledSkillCount: number;
   readonly localPersonaCount: number;
@@ -124,6 +127,16 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return { count: 0, enabled: 0 };
     }
   })();
+  const routineSnapshot = (() => {
+    try {
+      const shellPaths = context.workspace?.shellPaths;
+      if (!shellPaths) return { count: 0, enabled: 0 };
+      const snapshot = AgentRoutineRegistry.fromShellPaths(shellPaths).snapshot();
+      return { count: snapshot.routines.length, enabled: snapshot.enabledRoutines.length };
+    } catch {
+      return { count: 0, enabled: 0 };
+    }
+  })();
   const warnings: string[] = [];
   if (provider === 'unknown' || model === 'unknown') warnings.push('Provider/model unavailable in this runtime context.');
   if (!context.executeCommand) warnings.push('Command dispatch is unavailable; workspace actions will show guidance only.');
@@ -138,6 +151,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     daemonBaseUrl: `http://${host}:${port}`,
     daemonOwnership: 'external',
     sessionMemoryCount,
+    localRoutineCount: routineSnapshot.count,
+    enabledRoutineCount: routineSnapshot.enabled,
     localSkillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
     localPersonaCount: personaSnapshot.count,
@@ -193,10 +208,11 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     id: 'memory',
     group: 'LEARN',
     label: 'Memory & Skills',
-    summary: 'Local assistant memory, skills, and reusable behavior.',
-    detail: 'Memory, skills, and personas stay Agent-local until stable shared daemon registry contracts exist. Secrets must not be stored as memory.',
+    summary: 'Local assistant memory, routines, skills, and reusable behavior.',
+    detail: 'Memory, routines, skills, and personas stay Agent-local until stable shared daemon registry contracts exist. Secrets must not be stored as memory.',
     actions: [
       { id: 'memory', label: 'Open memory', detail: 'Inspect local/session memory commands and surfaces.', command: '/memory', kind: 'command', safety: 'read-only' },
+      { id: 'routines', label: 'Routine library', detail: 'Create, review, enable, and start local Agent routines in the main conversation.', command: '/routines', kind: 'command', safety: 'safe' },
       { id: 'skills', label: 'Local skill library', detail: 'Create, review, and enable local Agent reusable procedures.', command: '/agent-skills', kind: 'command', safety: 'safe' },
       { id: 'personas', label: 'Persona library', detail: 'Use local Agent personas to shape serial assistant behavior without spawning background agents.', command: '/personas', kind: 'command', safety: 'safe' },
     ],
@@ -233,7 +249,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Agent does not become the coding TUI. Build, implement, fix, patch, and review work must be handed to GoodVibes TUI with the full original ask and WRFC only when explicitly requested.',
     actions: [
       { id: 'delegate-guidance', label: 'Delegation rule', detail: 'For build/fix/review work, delegate one request to GoodVibes TUI instead of spawning local Engineer/Reviewer/Tester roots.', kind: 'guidance', safety: 'delegates' },
-      { id: 'review-command', label: 'Review delegation command', detail: 'Use /delegate --wrfc only when the user explicitly asks for code review/build execution.', command: '/delegate --wrfc <task>', kind: 'command', safety: 'delegates' },
+      { id: 'review-command', label: 'Review delegation command', detail: 'Use /delegate --wrfc <task> only when the user explicitly asks for code review/build execution. Close this workspace and include the actual task text.', kind: 'guidance', safety: 'delegates' },
       { id: 'remote-policy', label: 'Remote runner policy', detail: 'Remote dispatch/rerun is blocked in Agent; TUI owns runner topology for delegated build work.', command: '/remote dispatch', kind: 'command', safety: 'blocked' },
     ],
   },
@@ -395,6 +411,17 @@ export class AgentWorkspace {
       };
       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 = {

package/src/input/commands/control-room-runtime.ts

@@ -23,8 +23,8 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
   registry.register({
     name: 'orchestration',
     aliases: ['orch'],
-    description: 'Inspect orchestration graphs and cancel active graphs or subtrees',
-    usage: '[show [graphId] | cancel graph <graphId> | cancel subtree <agentId>]',
+    description: 'Inspect orchestration graphs; local Agent graph cancellation is blocked',
+    usage: '[show [graphId]]',
     handler(args, ctx) {
       const graphs = [...requireReadModels(ctx).orchestration.getSnapshot().graphs];
       if (args.length === 0) {
@@ -66,32 +66,11 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
       }
 
       if (subcommand === 'cancel') {
-        const mode = args[1]?.toLowerCase();
-        const target = args[2];
-        const manager = ctx.ops.agentManager;
-        if (!manager) {
-          ctx.print('Agent manager is not available in this runtime.');
-          return;
-        }
-        if (!mode || !target) {
-          ctx.print('Usage: /orchestration cancel graph <graphId> | /orchestration cancel subtree <agentId>');
-          return;
-        }
-        if (mode === 'graph') {
-          const cancelled = manager.cancelGraph(target);
-          ctx.print(cancelled.length > 0
-            ? `Cancelled ${cancelled.length} agent${cancelled.length !== 1 ? 's' : ''} in graph ${target}.`
-            : `No cancellable agents found in graph ${target}.`);
-          return;
-        }
-        if (mode === 'subtree') {
-          const cancelled = manager.cancelSubtree(target);
-          ctx.print(cancelled.length > 0
-            ? `Cancelled ${cancelled.length} agent${cancelled.length !== 1 ? 's' : ''} in subtree rooted at ${target}.`
-            : `No cancellable agents found in subtree rooted at ${target}.`);
-          return;
-        }
-        ctx.print(`Unknown orchestration cancel target: ${mode}`);
+        ctx.print([
+          'GoodVibes Agent orchestration is read-only.',
+          'Local graph/subtree cancellation belongs to the copied coding runtime and is blocked here.',
+          'For explicit build/fix/review work, use /delegate so GoodVibes TUI owns the execution chain.',
+        ].join('\n'));
         return;
       }
 

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

@@ -276,8 +276,8 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           `  discard: ${summary.discard}`,
           `  cleanup pending: ${summary.pendingCleanup}`,
           ...(issues.length > 0 ? issues.map((issue) => `  issue: ${issue}`) : ['  no active worktree lifecycle issues detected']),
-          '  next: /worktree review',
-          '  next: /worktree recover <session|task> <id>',
+          '  next: worktree recovery is externalized to GoodVibes TUI.',
+          '  next: use /delegate <task> only when the recovery is part of explicit build/fix/review work.',
         ].join('\n'));
         return;
       }
@@ -349,8 +349,8 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           lines.push('  verify: /health maintenance');
         } else if (domain === 'worktrees') {
           lines.push('  domain: worktrees');
-          lines.push('  /worktree review');
-          lines.push('  /worktree recover <session|task> <id>');
+          lines.push('  worktree recovery is externalized to GoodVibes TUI');
+          lines.push('  /delegate <task> when explicit build/fix/review work needs repository recovery');
           lines.push('  verify: /health worktrees');
         } else if (domain === 'intelligence') {
           lines.push('  domain: intelligence');

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

@@ -3,9 +3,19 @@ import { ToolContractVerifier } from '@/runtime/index.ts';
 import type { ReplaySnapshotInput } from '@/runtime/index.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
-import { requireOpsApi, requireProfileManager, requireReplayEngine } from './runtime-services.ts';
+import { requireProfileManager, requireReplayEngine } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
+function printOpsMutationBlocked(print: (text: string) => void, target: string): void {
+  print([
+    `[Ops] ${target} mutation is blocked in GoodVibes Agent.`,
+    '  policy: Agent does not control copied local task/agent lifecycle from the operator surface.',
+    '  normal work: continue in the main conversation.',
+    '  build/fix/review: use /delegate <task> for explicit GoodVibes TUI handoff.',
+    '  result: no local task or agent state was changed.',
+  ].join('\n'));
+}
+
 export function registerOperatorRuntimeCommands(registry: CommandRegistry): void {
   registerOperatorPanelCommand(registry);
 
@@ -175,9 +185,9 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
 
   registry.register({
     name: 'ops',
-    description: 'Operator Control Plane: view audit log, cancel/pause/resume/retry tasks and agents',
-    usage: 'view | task <cancel|pause|resume|retry> <id> [note] | agent cancel <id> [note]',
-    argsHint: '[view|task|agent]',
+    description: 'Operator Control Plane: view Agent operator posture without local task/agent lifecycle mutations',
+    usage: '[view]',
+    argsHint: '[view]',
     handler(args, ctx) {
       const sub = args[0];
 
@@ -188,57 +198,19 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
       }
 
       if (sub === 'task') {
-        const action = args[1];
-        const taskId = args[2];
-        const note = args.slice(3).join(' ') || undefined;
-        if (!action || !taskId) {
-          ctx.print('Usage: /ops task <cancel|pause|resume|retry> <task-id> [note]');
-          return;
-        }
-        const opsApi = requireOpsApi(ctx);
-        try {
-          switch (action) {
-            case 'cancel': opsApi.tasks.cancel(taskId, note); break;
-            case 'pause': opsApi.tasks.pause(taskId, note); break;
-            case 'resume': opsApi.tasks.resume(taskId, note); break;
-            case 'retry': opsApi.tasks.retry(taskId, note); break;
-            default:
-              ctx.print(`Unknown task action "${action}". Use: cancel, pause, resume, retry`);
-              return;
-          }
-          ctx.print(`[Ops] Task ${taskId}: ${action} dispatched.`);
-        } catch (e) {
-          ctx.print(`[Ops] Error: ${summarizeError(e)}`);
-        }
+        printOpsMutationBlocked(ctx.print, 'Task');
         return;
       }
 
       if (sub === 'agent') {
-        const action = args[1];
-        const agentId = args[2];
-        const note = args.slice(3).join(' ') || undefined;
-        if (action !== 'cancel' || !agentId) {
-          ctx.print('Usage: /ops agent cancel <agent-id> [note]');
-          return;
-        }
-        const opsApi = requireOpsApi(ctx);
-        try {
-          opsApi.agents.cancel(agentId, note);
-          ctx.print(`[Ops] Agent ${agentId}: cancel dispatched.`);
-        } catch (e) {
-          ctx.print(`[Ops] Error: ${summarizeError(e)}`);
-        }
+        printOpsMutationBlocked(ctx.print, 'Agent');
         return;
       }
 
       ctx.print(
         'Usage: /ops <subcommand>\n'
         + '  /ops view                              — open the Ops Control panel (Ctrl+O)\n'
-        + '  /ops task cancel <id> [note]           — cancel a task\n'
-        + '  /ops task pause  <id> [note]           — pause a task\n'
-        + '  /ops task resume <id> [note]           — resume a blocked task\n'
-        + '  /ops task retry  <id> [note]           — retry a failed task\n'
-        + '  /ops agent cancel <id> [note]          — cancel a running agent'
+        + '  task/agent lifecycle commands are blocked in Agent; use /delegate for explicit build handoff'
       );
     },
   });

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

@@ -3,12 +3,10 @@ import type { CommandRegistry, CommandContext } from '../command-registry.ts';
 import { AGENT_TEMPLATES } from '@pellux/goodvibes-sdk/platform/tools';
 import { handleRemoteSetupCommand } from './remote-runtime-setup.ts';
 import { handleRemotePoolCommand } from './remote-runtime-pool.ts';
-import { requireAgentManager, requireAcpManager, requirePeerClient } from './runtime-services.ts';
+import { requirePeerClient } from './runtime-services.ts';
 
 type RemoteConnectionLike = { agentId: string };
 type RemoteCancelContext = Pick<CommandContext, 'print'>;
-type RemoteCancelAgentManager = Pick<ReturnType<typeof requireAgentManager>, 'cancel'>;
-type RemoteCancelAcpManager = Pick<ReturnType<typeof requireAcpManager>, 'cancel'>;
 
 function printRemoteDelegationBoundary(ctx: Pick<CommandContext, 'print'>, requestedAction: string): void {
   ctx.print([
@@ -24,8 +22,6 @@ export function handleRemoteCancelCommand(
   agentId: string | undefined,
   activeConnections: RemoteConnectionLike[],
   ctx: RemoteCancelContext,
-  agentManager: RemoteCancelAgentManager,
-  acpManager?: RemoteCancelAcpManager,
 ): void {
   if (!agentId) {
     ctx.print('Usage: /remote cancel <agentId>');
@@ -36,17 +32,12 @@ export function handleRemoteCancelCommand(
     ctx.print(`Unknown remote connection: ${agentId}`);
     return;
   }
-  const localAgentCancelled = agentManager.cancel(agentId);
-  if (localAgentCancelled) {
-    ctx.print(`Cancelled remote agent ${agentId}.`);
-    return;
-  }
-  if (!acpManager) {
-    ctx.print(`Remote agent ${agentId} could not be cancelled in this runtime.`);
-    return;
-  }
-  void acpManager.cancel(agentId);
-  ctx.print(`Cancellation requested for remote runner ${agentId}.`);
+  ctx.print([
+    'GoodVibes Agent remote control is read-only.',
+    `  requested: /remote cancel ${agentId}`,
+    '  policy: Agent does not cancel local ACP/runner processes from this surface',
+    '  next: inspect with /remote show or delegate explicit build/fix/review work to GoodVibes TUI',
+  ].join('\n'));
 }
 
 export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
@@ -310,16 +301,10 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (subcommand === 'cancel') {
-        if (!ctx.ops.agentManager) {
-          ctx.print('Agent manager is not available in this runtime.');
-          return;
-        }
         handleRemoteCancelCommand(
           args[1],
           activeConnections,
           ctx,
-          requireAgentManager(ctx),
-          ctx.ops.acpManager ? requireAcpManager(ctx) : undefined,
         );
         return;
       }

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

@@ -0,0 +1,232 @@
+import { AgentRoutineRegistry, type AgentRoutineRecord } from '../../agent/routine-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+interface ParsedRoutineArgs {
+  readonly rest: readonly string[];
+  readonly flags: ReadonlyMap<string, string>;
+  readonly yes: boolean;
+}
+
+function parseRoutineArgs(args: readonly string[]): ParsedRoutineArgs {
+  const flags = new Map<string, string>();
+  const rest: string[] = [];
+  let yes = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? '';
+    if (token === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      const next = args[index + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags.set(key, next);
+        index += 1;
+      } else {
+        flags.set(key, 'true');
+      }
+      continue;
+    }
+    rest.push(token);
+  }
+  return { rest, flags, yes };
+}
+
+function splitList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function registryFromContext(ctx: CommandContext): AgentRoutineRegistry {
+  return AgentRoutineRegistry.fromShellPaths(requireShellPaths(ctx));
+}
+
+function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
+  const value = flags.get(key)?.trim();
+  if (!value) throw new Error(`Missing --${key}.`);
+  return value;
+}
+
+function summarizeRoutine(routine: AgentRoutineRecord): string {
+  const enabled = routine.enabled ? 'enabled' : 'disabled';
+  const tags = routine.tags.length > 0 ? ` tags=${routine.tags.join(',')}` : '';
+  return `  ${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
+}
+
+function renderList(title: string, registry: AgentRoutineRegistry, routines: readonly AgentRoutineRecord[]): string {
+  const snapshot = registry.snapshot();
+  if (routines.length === 0) {
+    return `${title}\n  No local Agent routines yet. Create one with /routines create --name <name> --description <summary> --steps <steps>.`;
+  }
+  return [
+    `${title} (${routines.length})`,
+    `  store: ${snapshot.path}`,
+    `  enabled: ${snapshot.enabledRoutines.length}`,
+    ...routines.map(summarizeRoutine),
+  ].join('\n');
+}
+
+function renderRoutine(routine: AgentRoutineRecord): string {
+  return [
+    `Routine ${routine.name}`,
+    `  id: ${routine.id}`,
+    `  enabled: ${routine.enabled ? 'yes' : 'no'}`,
+    `  review: ${routine.reviewState}`,
+    `  source: ${routine.source}`,
+    `  provenance: ${routine.provenance}`,
+    `  tags: ${routine.tags.join(', ') || '(none)'}`,
+    `  triggers: ${routine.triggers.join(', ') || '(manual)'}`,
+    `  started: ${routine.startCount}${routine.lastStartedAt ? `; last ${routine.lastStartedAt}` : ''}`,
+    `  created: ${routine.createdAt}`,
+    `  updated: ${routine.updatedAt}`,
+    routine.staleReason ? `  stale reason: ${routine.staleReason}` : '',
+    '',
+    routine.description,
+    '',
+    routine.steps,
+  ].filter(Boolean).join('\n');
+}
+
+function printError(ctx: CommandContext, error: unknown): void {
+  ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
+  const sub = (args[0] ?? 'list').toLowerCase();
+  const routineRegistry = registryFromContext(ctx);
+  try {
+    if (sub === 'list' || sub === 'open') {
+      ctx.print(renderList('Agent Routines', routineRegistry, routineRegistry.list()));
+      return;
+    }
+    if (sub === 'enabled') {
+      const snapshot = routineRegistry.snapshot();
+      ctx.print(renderList('Enabled Agent Routines', routineRegistry, snapshot.enabledRoutines));
+      return;
+    }
+    if (sub === 'search') {
+      const query = args.slice(1).join(' ').trim();
+      ctx.print(renderList(query ? `Agent Routines matching "${query}"` : 'Agent Routines', routineRegistry, routineRegistry.search(query)));
+      return;
+    }
+    if (sub === 'show') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /routines show <id>');
+        return;
+      }
+      const routine = routineRegistry.get(id);
+      ctx.print(routine ? renderRoutine(routine) : `Unknown Agent routine: ${id}`);
+      return;
+    }
+    if (sub === 'create') {
+      const parsed = parseRoutineArgs(args.slice(1));
+      const steps = parsed.flags.get('steps')?.trim() || parsed.rest.join(' ').trim();
+      const routine = routineRegistry.create({
+        name: requiredFlag(parsed.flags, 'name'),
+        description: requiredFlag(parsed.flags, 'description'),
+        steps,
+        triggers: splitList(parsed.flags.get('triggers')),
+        tags: splitList(parsed.flags.get('tags')),
+        enabled: parsed.flags.get('enabled') === 'true',
+        source: 'user',
+        provenance: 'slash-command',
+      });
+      ctx.print(`Created Agent routine ${routine.id}: ${routine.name}`);
+      return;
+    }
+    if (sub === 'update') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /routines update <id> [--name ...] [--description ...] [--steps ...]');
+        return;
+      }
+      const parsed = parseRoutineArgs(args.slice(2));
+      const updated = routineRegistry.update(id, {
+        name: parsed.flags.get('name'),
+        description: parsed.flags.get('description'),
+        steps: parsed.flags.get('steps'),
+        triggers: parsed.flags.has('triggers') ? splitList(parsed.flags.get('triggers')) : undefined,
+        tags: parsed.flags.has('tags') ? splitList(parsed.flags.get('tags')) : undefined,
+        provenance: 'slash-command',
+      });
+      ctx.print(`Updated Agent routine ${updated.id}: ${updated.name}`);
+      return;
+    }
+    if (sub === 'enable' || sub === 'disable') {
+      const id = args[1];
+      if (!id) {
+        ctx.print(`Usage: /routines ${sub} <id>`);
+        return;
+      }
+      const routine = routineRegistry.setEnabled(id, sub === 'enable');
+      ctx.print(`${sub === 'enable' ? 'Enabled' : 'Disabled'} Agent routine ${routine.id}: ${routine.name}`);
+      return;
+    }
+    if (sub === 'start' || sub === 'run') {
+      const id = args[1];
+      if (!id) {
+        ctx.print(`Usage: /routines ${sub} <id>`);
+        return;
+      }
+      const routine = routineRegistry.markStarted(id);
+      ctx.print([
+        `Started Agent routine ${routine.id}: ${routine.name}`,
+        '  policy: same main conversation; no hidden background job, daemon mutation, or external side effect was started',
+        '',
+        routine.steps,
+      ].join('\n'));
+      return;
+    }
+    if (sub === 'review') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /routines review <id>');
+        return;
+      }
+      const routine = routineRegistry.markReviewed(id);
+      ctx.print(`Reviewed Agent routine ${routine.id}.`);
+      return;
+    }
+    if (sub === 'stale') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /routines stale <id> <reason...>');
+        return;
+      }
+      const routine = routineRegistry.markStale(id, args.slice(2).join(' '));
+      ctx.print(`Marked Agent routine ${routine.id} stale.`);
+      return;
+    }
+    if (sub === 'delete' || sub === 'remove') {
+      const parsed = parseRoutineArgs(args.slice(1));
+      const id = parsed.rest[0];
+      if (!id) {
+        ctx.print('Usage: /routines delete <id> --yes');
+        return;
+      }
+      if (!parsed.yes) {
+        ctx.print(`Refusing to delete Agent routine ${id} without --yes.`);
+        return;
+      }
+      const removed = routineRegistry.deleteRoutine(id);
+      ctx.print(`Deleted Agent routine ${removed.id}: ${removed.name}`);
+      return;
+    }
+    ctx.print('Usage: /routines [list|enabled|search|show|create|update|enable|disable|start|review|stale|delete]');
+  } catch (error) {
+    printError(ctx, error);
+  }
+}
+
+export function registerRoutinesRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'routines',
+    aliases: ['routine'],
+    description: 'Manage local GoodVibes Agent routines',
+    usage: '[list|enabled|search <query>|show <id>|create --name <name> --description <summary> --steps <steps>|update <id> [--name ...] [--description ...] [--steps ...]|enable <id>|disable <id>|start <id>|review <id>|stale <id> <reason...>|delete <id> --yes]',
+    handler: runRoutinesRuntimeCommand,
+  });
+}

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

@@ -113,14 +113,8 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         timestamp: Date.now(),
       };
       try {
-        const agentManager = ctx.ops.agentManager;
-        if (!agentManager) {
-          ctx.print('Agent manager is not available in this runtime.');
-          return;
-        }
-        const agentRecords = agentManager.exportState();
-        const { filePath, sanitizedName } = sessionManager.save(rawName, messages, meta, agentRecords);
-        ctx.print(`Session saved: ${rawName}${sanitizedName !== rawName ? ` (saved as "${sanitizedName}")` : ''}${agentRecords.length > 0 ? ` [${agentRecords.length} agent records]` : ''}\n  → ${filePath}`);
+        const { filePath, sanitizedName } = sessionManager.save(rawName, messages, meta);
+        ctx.print(`Session saved: ${rawName}${sanitizedName !== rawName ? ` (saved as "${sanitizedName}")` : ''}\n  → ${filePath}`);
       } catch (e) {
         ctx.print(`Failed to save session: ${summarizeError(e)}`);
       }
@@ -140,19 +134,12 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       const sessionManager = requireSessionManager(ctx);
       try {
         const { meta, messages, agentRecords } = sessionManager.load(args[0]);
-        const agentManager = ctx.ops.agentManager;
-        if (!agentManager) {
-          ctx.print('Agent manager is not available in this runtime.');
-          return;
-        }
         ctx.session.conversationManager.resetAll();
         ctx.session.conversationManager.fromJSON({ messages: messages as never[] });
         if (meta.title) ctx.session.conversationManager.title = meta.title;
         ctx.session.conversationManager.rebuildHistory();
-        agentManager.clear();
-        if (agentRecords.length > 0) agentManager.importState(agentRecords);
         ctx.renderRequest();
-        ctx.print(`Session loaded: ${args[0]} (${messages.length} messages)${agentRecords.length > 0 ? ` [${agentRecords.length} agent records restored]` : ''}`);
+        ctx.print(`Session loaded: ${args[0]} (${messages.length} messages)${agentRecords.length > 0 ? ` [ignored ${agentRecords.length} copied local agent record${agentRecords.length !== 1 ? 's' : ''}]` : ''}`);
       } catch (e) {
         ctx.print(`Failed to load session: ${summarizeError(e)}`);
       }

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

@@ -266,7 +266,7 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
           ctx.print(`  Remote re-entry: /remote recover ${meta.returnContext.remoteRunners![0]}`);
         }
         if ((meta.returnContext.worktreePaths?.length ?? 0) > 0) {
-          ctx.print(`  Worktree re-entry: /worktree review`);
+          ctx.print('  Worktree re-entry: open GoodVibes TUI in the target workspace; Agent /worktree is externalized.');
         }
         if (returnContextMode === 'assisted') {
           const helperModel = providerApi.createHelperModel(ctx.platform.configManager);