@pellux/goodvibes-agent 0.1.7 → 0.1.8

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);

package/src/input/commands/session.ts

@@ -1,20 +1,9 @@
 /**
  * /session command handler — Multi-session Orchestration.
  *
- * Implements session and workflow commands:
- *
- *   /session link-task <taskId> [--session <sessionId>] [--depends-on <ref>] [--label <label>]
- *     — Register a task as a global cross-session ref, optionally linking it to a
- *       dependency.
- *
- *   /session handoff <taskId> --to <sessionId> [--session <sessionId>] [--reason <reason>]
- *     — Initiate a task handoff from the current session to another.
- *
- *   /session graph [--session <sessionId>] [--format text|json]
- *     — Display the cross-session task dependency graph.
- *
- *   /session cancel <taskId|--scope session> [--session <sessionId>] [--scope task|subtree|session]
- *     — Cancel tasks with configurable scope semantics.
+ * Implements read-only session graph inspection plus session continuity commands.
+ * Copied local task graph mutation commands are blocked in Agent; explicit
+ * build/fix/review handoff must use `/delegate` so GoodVibes TUI owns execution.
  */
 
 import type { SlashCommand, CommandContext } from '../command-registry.ts';
@@ -72,6 +61,14 @@ function fmtRef(ref: CrossSessionTaskRef): string {
   return `${statusBadge(ref.status)} ${key}${label}  "${ref.title}"`;
 }
 
+function printSessionGraphMutationBlocked(context: CommandContext): void {
+  context.print([
+    '[session] Local cross-session task graph mutation is blocked in GoodVibes Agent.',
+    '[session] Use /session graph for read-only inspection.',
+    '[session] Use /delegate <task> for explicit build/fix/review handoff to GoodVibes TUI.',
+  ].join('\n'));
+}
+
 // ── /session link-task ────────────────────────────────────────────────────────
 
 function handleLinkTask(args: string[], context: CommandContext): void {
@@ -192,7 +189,7 @@ function handleGraph(args: string[], context: CommandContext): void {
     if (filterSession) {
       context.print(`[session] No tasks registered for session ${filterSession.slice(0, 8)}...`);
     } else {
-      context.print('[session] Task graph is empty. Use /session link-task to register tasks.');
+      context.print('[session] Task graph is empty. Local task graph mutation is blocked in Agent; use /delegate for explicit build/fix/review handoff.');
     }
     return;
   }
@@ -324,21 +321,21 @@ function handleCancel(args: string[], context: CommandContext): void {
 export const sessionCommand: SlashCommand = {
   name: 'session',
   aliases: ['sess'],
-  description: 'Multi-session orchestration: link tasks, handoff, view graph, and cancel across sessions.',
+  description: 'Session continuity and read-only cross-session graph inspection.',
   usage: '<subcommand> [args]',
-  argsHint: 'link-task|handoff|graph|cancel',
+  argsHint: 'list|resume|save|graph',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
     switch (sub) {
       case 'link-task':
       case 'link':
-        handleLinkTask(rest, context);
+        printSessionGraphMutationBlocked(context);
         break;
 
       case 'handoff':
       case 'ho':
-        handleHandoff(rest, context);
+        printSessionGraphMutationBlocked(context);
         break;
 
       case 'graph':
@@ -347,7 +344,7 @@ export const sessionCommand: SlashCommand = {
         break;
 
       case 'cancel':
-        handleCancel(rest, context);
+        printSessionGraphMutationBlocked(context);
         break;
 
       default: {
@@ -357,14 +354,10 @@ export const sessionCommand: SlashCommand = {
             'Usage: /session <subcommand>',
             '  list | rename <name> | resume <id|name> | fork [name] | save [name] | info [id] | export <id> [format] | search <query> | delete <id>',
             '                                 — Session continuity, export, resume, and pruning',
-            '  link-task <taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
-            '                                 — Register a task in the cross-session graph',
-            '  handoff <taskId> --to <sid>  [--session <sid>] [--reason <reason>]',
-            '                                 — Hand a task off to another session',
             '  graph [--session <sid>] [--format text|json]',
             '                                 — Display the cross-session task dependency graph',
-            '  cancel <taskId> [--scope task|subtree|session] [--session <sid>] [--reason <reason>]',
-            '                                 — Cancel tasks with scoped semantics',
+            '  link-task | handoff | cancel',
+            '                                 — Blocked in Agent; use /delegate for explicit build/fix/review handoff',
           ].join('\n');
           context.print(usage);
         }