@pellux/goodvibes-agent 1.1.7 → 1.2.0

package/src/runtime/execution-ledger.ts

@@ -0,0 +1,231 @@
+import type { RuntimeEventBus, ToolEvent } from '@/runtime/index.ts';
+
+export type AgentExecutionStatus = 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type AgentExecutionRouteKind = 'read' | 'write' | 'shell' | 'network' | 'browser' | 'delegation' | 'other';
+
+export interface AgentExecutionResultSummary {
+  readonly kind: string;
+  readonly byteSize: number;
+  readonly preview?: string | undefined;
+}
+
+export interface AgentExecutionRecord {
+  readonly id: string;
+  readonly callId: string;
+  readonly turnId: string;
+  readonly tool: string;
+  readonly routeKind: AgentExecutionRouteKind;
+  readonly status: AgentExecutionStatus;
+  readonly phase: ToolEvent['type'];
+  readonly receivedAt: number;
+  readonly updatedAt: number;
+  readonly completedAt?: number | undefined;
+  readonly durationMs?: number | undefined;
+  readonly permissionApproved?: boolean | undefined;
+  readonly argsPreview: string;
+  readonly argsKeys: readonly string[];
+  readonly commandPreview?: string | undefined;
+  readonly targetPreview?: string | undefined;
+  readonly resultSummary?: AgentExecutionResultSummary | undefined;
+  readonly error?: string | undefined;
+  readonly cancelReason?: string | undefined;
+}
+
+interface MutableAgentExecutionRecord {
+  id: string;
+  callId: string;
+  turnId: string;
+  tool: string;
+  routeKind: AgentExecutionRouteKind;
+  status: AgentExecutionStatus;
+  phase: ToolEvent['type'];
+  receivedAt: number;
+  updatedAt: number;
+  completedAt?: number | undefined;
+  durationMs?: number | undefined;
+  permissionApproved?: boolean | undefined;
+  argsPreview: string;
+  argsKeys: readonly string[];
+  commandPreview?: string | undefined;
+  targetPreview?: string | undefined;
+  resultSummary?: AgentExecutionResultSummary | undefined;
+  error?: string | undefined;
+  cancelReason?: string | undefined;
+}
+
+export interface AgentExecutionLedgerSnapshot {
+  readonly records: readonly AgentExecutionRecord[];
+  readonly total: number;
+  readonly running: number;
+  readonly succeeded: number;
+  readonly failed: number;
+  readonly cancelled: number;
+}
+
+const DEFAULT_LIMIT = 500;
+const SECRET_KEY_PATTERN = /(?:api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
+
+function truncateText(value: string, max = 220): string {
+  const compact = value.replace(/\s+/g, ' ').trim();
+  return compact.length > max ? `${compact.slice(0, Math.max(0, max - 1))}...` : compact;
+}
+
+function redactValue(value: unknown, depth = 0): unknown {
+  if (depth > 3) return '[truncated]';
+  if (typeof value === 'string') return truncateText(value);
+  if (typeof value === 'number' || typeof value === 'boolean' || value === null) return value;
+  if (Array.isArray(value)) return value.slice(0, 8).map((entry) => redactValue(entry, depth + 1));
+  if (!value || typeof value !== 'object') return String(value);
+  const entries = Object.entries(value as Record<string, unknown>).slice(0, 16).map(([key, entry]) => (
+    [key, SECRET_KEY_PATTERN.test(key) ? '[redacted]' : redactValue(entry, depth + 1)] as const
+  ));
+  return Object.fromEntries(entries);
+}
+
+function argsPreview(args: Record<string, unknown>): string {
+  try {
+    return truncateText(JSON.stringify(redactValue(args)), 360);
+  } catch {
+    return '[unserializable args]';
+  }
+}
+
+function stringArg(args: Record<string, unknown>, keys: readonly string[]): string | undefined {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === 'string' && value.trim()) return truncateText(value, 180);
+  }
+  return undefined;
+}
+
+function routeKindForTool(tool: string, args: Record<string, unknown>): AgentExecutionRouteKind {
+  const name = tool.toLowerCase();
+  if (name.includes('browser') || name.includes('desktop') || name.includes('screenshot')) return 'browser';
+  if (name.includes('delegate') || name.includes('agent')) return 'delegation';
+  if (name.includes('exec') || name.includes('shell') || name.includes('bash') || typeof args.command === 'string') return 'shell';
+  if (name.includes('write') || name.includes('edit') || name.includes('patch') || name.includes('delete')) return 'write';
+  if (name.includes('fetch') || name.includes('web') || name.includes('http') || name.includes('url')) return 'network';
+  if (name.includes('read') || name.includes('find') || name.includes('inspect') || name.includes('grep') || name.includes('search')) return 'read';
+  return 'other';
+}
+
+function statusForPhase(phase: ToolEvent['type']): AgentExecutionStatus {
+  if (phase === 'TOOL_SUCCEEDED') return 'succeeded';
+  if (phase === 'TOOL_FAILED') return 'failed';
+  if (phase === 'TOOL_CANCELLED') return 'cancelled';
+  return 'running';
+}
+
+function resultSummaryFrom(value: Extract<ToolEvent, { type: 'TOOL_SUCCEEDED' | 'TOOL_FAILED' }>['result']): AgentExecutionResultSummary | undefined {
+  if (!value) return undefined;
+  return {
+    kind: value.kind,
+    byteSize: value.byteSize,
+    ...(typeof value.preview === 'string' && value.preview.trim() ? { preview: truncateText(value.preview, 220) } : {}),
+  };
+}
+
+function immutable(record: MutableAgentExecutionRecord): AgentExecutionRecord {
+  return { ...record };
+}
+
+export class AgentExecutionLedger {
+  private readonly records = new Map<string, MutableAgentExecutionRecord>();
+  private readonly order: string[] = [];
+  private readonly subscribers = new Set<() => void>();
+  private readonly unsubscribe: () => void;
+
+  public constructor(
+    runtimeBus: RuntimeEventBus,
+    private readonly limit: number = DEFAULT_LIMIT,
+  ) {
+    this.unsubscribe = runtimeBus.onDomain('tools', (envelope) => {
+      this.handleToolEvent(envelope.payload as ToolEvent, envelope.ts);
+    });
+  }
+
+  public getSnapshot(): AgentExecutionLedgerSnapshot {
+    const records = this.order
+      .map((id) => this.records.get(id))
+      .filter((record): record is MutableAgentExecutionRecord => record !== undefined)
+      .map(immutable)
+      .reverse();
+    return {
+      records,
+      total: records.length,
+      running: records.filter((record) => record.status === 'running').length,
+      succeeded: records.filter((record) => record.status === 'succeeded').length,
+      failed: records.filter((record) => record.status === 'failed').length,
+      cancelled: records.filter((record) => record.status === 'cancelled').length,
+    };
+  }
+
+  public subscribe(callback: () => void): () => void {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+
+  public dispose(): void {
+    this.unsubscribe();
+    this.subscribers.clear();
+  }
+
+  private handleToolEvent(event: ToolEvent, timestamp: number): void {
+    if (!('callId' in event)) return;
+    if (event.type === 'TOOL_RECEIVED') {
+      this.recordReceived(event, timestamp);
+      return;
+    }
+    const existing = this.records.get(event.callId);
+    if (!existing) return;
+    existing.phase = event.type;
+    existing.status = statusForPhase(event.type);
+    existing.updatedAt = timestamp;
+    if (event.type === 'TOOL_PERMISSIONED') existing.permissionApproved = event.approved;
+    if (event.type === 'TOOL_SUCCEEDED') {
+      existing.completedAt = timestamp;
+      existing.durationMs = event.durationMs;
+      existing.resultSummary = resultSummaryFrom(event.result);
+    }
+    if (event.type === 'TOOL_FAILED') {
+      existing.completedAt = timestamp;
+      existing.durationMs = event.durationMs;
+      existing.error = truncateText(event.error, 220);
+      existing.resultSummary = resultSummaryFrom(event.result);
+    }
+    if (event.type === 'TOOL_CANCELLED') {
+      existing.completedAt = timestamp;
+      existing.cancelReason = event.reason ? truncateText(event.reason, 220) : undefined;
+    }
+    this.notify();
+  }
+
+  private recordReceived(event: Extract<ToolEvent, { type: 'TOOL_RECEIVED' }>, timestamp: number): void {
+    const record: MutableAgentExecutionRecord = {
+      id: event.callId,
+      callId: event.callId,
+      turnId: event.turnId,
+      tool: event.tool,
+      routeKind: routeKindForTool(event.tool, event.args),
+      status: 'running',
+      phase: event.type,
+      receivedAt: timestamp,
+      updatedAt: timestamp,
+      argsPreview: argsPreview(event.args),
+      argsKeys: Object.keys(event.args).filter((key) => !SECRET_KEY_PATTERN.test(key)).sort(),
+      commandPreview: stringArg(event.args, ['command', 'cmd', 'script']),
+      targetPreview: stringArg(event.args, ['path', 'file', 'target', 'url', 'query', 'task']),
+    };
+    this.records.set(record.id, record);
+    this.order.push(record.id);
+    while (this.order.length > this.limit) {
+      const dropped = this.order.shift();
+      if (dropped) this.records.delete(dropped);
+    }
+    this.notify();
+  }
+
+  private notify(): void {
+    for (const callback of this.subscribers) callback();
+  }
+}

package/src/runtime/services.ts

@@ -9,6 +9,7 @@ import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } fr
 import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
 import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
 import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { SharedSessionRoutingIntent } from '@pellux/goodvibes-sdk/platform/control-plane';
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
 import {
@@ -89,6 +90,7 @@ import {
   type WorkflowServices,
 } from '@pellux/goodvibes-sdk/platform/tools';
 import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+import { AgentExecutionLedger } from './execution-ledger.ts';
 
 type WorktreeRegistry = RuntimeShell.WorktreeRegistry;
 type SdkRuntimeServices = RuntimeFoundationClientsOptions['runtimeServices'];
@@ -130,6 +132,64 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
   };
 }
 
+function normalizeSharedSessionModelId(modelId: string | undefined, providerId: string | undefined): string | undefined {
+  const trimmedModelId = modelId?.trim();
+  if (!trimmedModelId) return undefined;
+  const trimmedProviderId = providerId?.trim();
+  const separatorIndex = trimmedModelId.indexOf(':');
+  if (separatorIndex > 0) return trimmedModelId;
+  if (trimmedProviderId) return `${trimmedProviderId}:${trimmedModelId}`;
+  return trimmedModelId;
+}
+
+function normalizeSharedSessionFallbackModels(models: readonly string[] | undefined): string[] {
+  return (models ?? [])
+    .filter((model): model is string => typeof model === 'string' && model.trim().length > 0)
+    .map((model) => {
+      const trimmed = model.trim();
+      const separatorIndex = trimmed.indexOf(':');
+      if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+        throw new Error(`Shared-session fallback model '${model}' must be provider-qualified.`);
+      }
+      return trimmed;
+    });
+}
+
+function buildAgentSpawnRoutingFromSharedSession(
+  routing: SharedSessionRoutingIntent | undefined,
+  options: { readonly restrictTools?: boolean | undefined } = {},
+): Partial<Parameters<AgentManager['spawn']>[0]> {
+  if (!routing) return options.restrictTools ? { restrictTools: true } : {};
+  const provider = routing.providerId?.trim();
+  const model = normalizeSharedSessionModelId(routing.modelId, provider);
+  if (provider && !model) {
+    throw new Error('Shared-session provider routing requires a provider-qualified model when provider is supplied.');
+  }
+  const fallbackModels = normalizeSharedSessionFallbackModels(routing.fallbackModels);
+  const providerFailurePolicy = routing.providerFailurePolicy ?? (
+    fallbackModels.length ? 'ordered-fallbacks' : 'fail'
+  );
+  if (providerFailurePolicy === 'ordered-fallbacks' && fallbackModels.length === 0) {
+    throw new Error('Shared-session ordered fallback routing requires at least one provider-qualified fallback model.');
+  }
+  if (providerFailurePolicy === 'fail' && fallbackModels.length > 0) {
+    throw new Error('Shared-session fail routing cannot include fallback models; use ordered-fallbacks to enable model failover.');
+  }
+  return {
+    ...(model ? { model } : {}),
+    ...(provider ? { provider } : {}),
+    ...(routing.tools?.length ? { tools: [...routing.tools] } : {}),
+    ...(options.restrictTools ? { restrictTools: true } : {}),
+    routing: {
+      providerSelection: routing.providerSelection ?? (provider ? 'concrete' : 'inherit-current'),
+      providerFailurePolicy,
+      ...(fallbackModels.length ? { fallbackModels } : {}),
+    },
+    ...(routing.executionIntent ? { executionIntent: routing.executionIntent } : {}),
+    ...(routing.reasoningEffort ? { reasoningEffort: routing.reasoningEffort } : {}),
+  };
+}
+
 class DisabledAgentWorktreeRegistry extends runtimeShell.WorktreeRegistry {
   public override async list(): Promise<Awaited<ReturnType<WorktreeRegistry['list']>>> {
     return [] as Awaited<ReturnType<WorktreeRegistry['list']>>;
@@ -405,6 +465,7 @@ export interface RuntimeServices extends SdkRuntimeServices {
   readonly processManager: ProcessManager;
   readonly modeManager: ModeManager;
   readonly fileUndoManager: FileUndoManager;
+  readonly executionLedger: AgentExecutionLedger;
   readonly integrationHelpers: IntegrationHelperService;
   /**
    * Re-root workspace-bound stores to a new working directory.
@@ -516,6 +577,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
     createWorktree: createDisabledAgentWrfcWorktreeOps,
   }]) as WrfcController;
+  agentManager.setWrfcController(wrfcController);
   const hookDispatcher = new HookDispatcher({ toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
   configManager.attachHookDispatcher(hookDispatcher);
   const hookWorkbench = createHookWorkbench({
@@ -532,11 +594,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     messageSender: agentMessageBus,
   });
   sessionBroker.setContinuationRunner(async ({ task, input }) => {
-    throw new Error([
-      'GoodVibes Agent does not own shared-session task execution.',
-      `Received task for session ${input.sessionId}: ${task}`,
-      'Delegate explicit build/fix/review work to GoodVibes TUI through the public shared-session/build-delegation contract.',
-    ].join(' '));
+    const record = agentManager.spawn({
+      mode: 'spawn',
+      task,
+      ...buildAgentSpawnRoutingFromSharedSession(input.routing, { restrictTools: true }),
+      context: `shared-session:${input.sessionId}`,
+    });
+    return { agentId: record.id };
   });
   const artifactStore = new ArtifactStore({ configManager });
   const memoryEmbeddingRegistry = new MemoryEmbeddingProviderRegistry({ configManager });
@@ -562,11 +626,23 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeBus: options.runtimeBus,
     deliveryManager,
     spawnTask: (input) => {
-      throw new Error([
-        'GoodVibes Agent does not create local automation jobs and does not spawn local automation agents.',
-        `Received automation prompt: ${input.prompt}`,
-        'Use read-only automation observability here; explicit build/fix/review execution belongs to GoodVibes TUI delegation.',
-      ].join(' '));
+      const record = agentManager.spawn({
+        mode: 'spawn',
+        task: input.prompt,
+        ...(input.modelId ? { model: input.modelId } : {}),
+        ...(input.modelProvider ? { provider: input.modelProvider } : {}),
+        ...(input.fallbackModels ? { fallbackModels: [...input.fallbackModels] } : {}),
+        ...(input.routing ? { routing: input.routing } : {}),
+        ...(input.executionIntent ? { executionIntent: input.executionIntent } : {}),
+        ...(input.template ? { template: input.template } : {}),
+        ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
+        ...(input.toolAllowlist ? { tools: [...input.toolAllowlist], restrictTools: true } : {}),
+        context: [
+          'automation-manager:visible-agent',
+          input.context,
+        ].filter((part): part is string => Boolean(part?.trim())).join('\n\n'),
+      });
+      return record.id;
     },
   });
   const agentKnowledgeStore = new KnowledgeStore({
@@ -684,6 +760,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const processManager = new ProcessManager();
   const modeManager = new ModeManager();
   const fileUndoManager = new FileUndoManager();
+  const executionLedger = new AgentExecutionLedger(options.runtimeBus);
   const integrationHelpers = new IntegrationHelperService({
     workingDirectory,
     homeDirectory,
@@ -816,6 +893,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     processManager,
     modeManager,
     fileUndoManager,
+    executionLedger,
     integrationHelpers,
     async rerootStores(newWorkingDir: string): Promise<void> {
       await projectIndex.reroot(newWorkingDir);

package/src/runtime/tool-permission-safety.ts

@@ -17,7 +17,25 @@ const READ_TOOL_NAMES = new Set([
   'inspect',
   'state',
   'registry',
+  'route',
   'goodvibes_context',
+  'autonomy',
+  'channels',
+  'computer',
+  'context',
+  'delegation',
+  'device',
+  'execution',
+  'host',
+  'memory',
+  'models',
+  'personal_ops',
+  'research',
+  'security',
+  'setup',
+  'settings',
+  'vibe',
+  'workspace',
   'agent_harness',
   'agent_knowledge',
   'agent_operator_briefing',
@@ -27,12 +45,36 @@ const WRITE_TOOL_NAMES = new Set([
   'write',
   'edit',
   'goodvibes_settings',
+  'agent_artifacts',
+  'agent_documents',
   'agent_knowledge_ingest',
+  'agent_learning_consolidation',
   'agent_local_registry',
+  'agent_research_runs',
+  'agent_research_sources',
+  'agent_research_report',
+  'agent_review_packet_presets',
   'agent_work_plan',
 ]);
 
-const EXECUTE_TOOL_NAMES = new Set(['exec', 'repl']);
+const EXECUTE_TOOL_NAMES = new Set(['exec', 'repl', 'terminal', 'process']);
+const READ_ONLY_PROCESS_ACTIONS = new Set(['', 'list', 'status', 'poll', 'log', 'output', 'capabilities', 'doctor', 'parity']);
+const READ_ONLY_SCHEDULE_ACTIONS = new Set(['', 'list', 'status', 'show']);
+const READ_ONLY_SETTINGS_IMPORT_ACTIONS = new Set(['', 'preview', 'inspect', 'show', 'plan']);
+const READ_ONLY_SETTINGS_ACTIONS = new Set(['', 'list', 'status', 'settings', 'catalog', 'search', 'find', 'browse', 'get', 'show', 'inspect', 'read', 'setting', 'get_setting', 'import', 'import_settings', 'settings_import', 'import_goodvibes', 'goodvibes_import', 'preview_import']);
+const READ_ONLY_SETUP_ACTIONS = new Set(['', 'status', 'summary', 'list', 'item', 'show', 'inspect', 'repair', 'fix', 'diagnose_repair', 'host_repair', 'repair_host', 'launch_host', 'checkpoint', 'checkpoint_status']);
+const READ_ONLY_VIBE_ACTIONS = new Set(['', 'status', 'summary', 'list', 'show', 'file', 'source', 'read', 'inspect']);
+const READ_ONLY_PERSONAL_OPS_ACTIONS = new Set(['', 'briefing', 'brief', 'daily', 'daily_brief', 'morning', 'status', 'summary', 'overview', 'map', 'list', 'queue', 'queues', 'review_queue', 'review_queues', 'personal_queue', 'ops_queue', 'intake', 'request', 'route', 'plan', 'triage', 'draft', 'lane', 'inspect', 'show']);
+const READ_ONLY_RESEARCH_ACTIONS = new Set(['', 'briefing', 'brief', 'status', 'dashboard', 'cockpit', 'next', 'plan', 'workflow', 'research', 'runner', 'browser', 'browser_runner', 'browser_backed', 'deep_research', 'runs', 'list_runs', 'run_list', 'run', 'show_run', 'inspect_run', 'sources', 'queue', 'source_queue', 'source', 'show_source', 'inspect_source', 'bundle', 'bundle_sources', 'source_bundle', 'search', 'public_search', 'collect', 'collect_sources', 'source_candidates', 'reports', 'list_reports', 'report_list', 'visual_reports', 'report_artifact', 'show_report', 'inspect_report', 'show_visual_report', 'visual_report_artifact']);
+const READ_ONLY_CHANNELS_ACTIONS = new Set(['', 'status', 'summary', 'list', 'readiness', 'channels', 'channel', 'show', 'inspect', 'setup', 'guide', 'setup_guide', 'channel_setup_guide', 'triage', 'inbox', 'blockers', 'retries', 'channel_triage', 'deliveries', 'delivery', 'receipts', 'history', 'channel_deliveries']);
+const READ_ONLY_MEMORY_ACTIONS = new Set(['', 'status', 'summary', 'posture', 'memory_posture', 'recall', 'providers', 'provider', 'memory_provider', 'embedding', 'external', 'external_provider', 'curator', 'learning', 'learning_curator', 'queue', 'review_queue', 'plan', 'candidate', 'learning_candidate', 'card', 'inspect_candidate', 'list', 'records', 'memories', 'search', 'find', 'lookup', 'get', 'show', 'inspect', 'read']);
+const READ_ONLY_COMPUTER_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'computer', 'computer_use', 'plan', 'route', 'control_plan', 'browser_plan', 'desktop_plan', 'control', 'browser_control', 'desktop', 'desktop_control', 'screenshot', 'screen', 'screen_recording', 'observe', 'browser', 'pwa', 'cockpit', 'browser_cockpit', 'web', 'setup', 'configure', 'browser_desktop_control', 'mcp', 'tools', 'servers', 'mcp_servers']);
+const READ_ONLY_DEVICE_ACTIONS = new Set(['', 'status', 'map', 'capabilities', 'device', 'devices', 'mobile', 'phone', 'pairing', 'capability', 'route', 'pairing_route', 'show', 'inspect', 'browser', 'pwa', 'cockpit', 'browser_cockpit', 'web', 'control', 'browser_control', 'desktop', 'desktop_control', 'computer_use', 'voice', 'media', 'voice_media', 'workflows', 'provider', 'media_provider', 'voice_provider']);
+const READ_ONLY_MODELS_ACTIONS = new Set(['', 'status', 'routing', 'routes', 'models', 'model', 'readiness', 'route_readiness', 'route', 'model_route', 'inspect', 'show', 'candidate', 'endpoint', 'local', 'cookbook', 'local_cookbook', 'recipes', 'recipe', 'ollama', 'llama_cpp', 'llamacpp', 'vllm', 'local_servers', 'providers', 'provider_accounts', 'accounts', 'subscriptions', 'auth', 'logins', 'provider', 'provider_account', 'account', 'subscription', 'auth_status']);
+const READ_ONLY_WORKSPACE_ACTIONS = new Set(['', 'status', 'summary', 'home', 'workspace', 'categories', 'workspace_categories', 'actions', 'list_actions', 'workspace_actions', 'tasks', 'action', 'show', 'inspect', 'workspace_action', 'surfaces', 'ui_surfaces', 'screens', 'views', 'surface', 'ui_surface', 'screen', 'view', 'panels', 'panes', 'panel', 'pane', 'shortcuts', 'shortcut_help', 'help', 'keybindings', 'bindings', 'keys', 'keybinding', 'binding', 'key', 'commands', 'slash_commands', 'command_catalog', 'command', 'slash_command', 'inspect_command', 'cli_commands', 'cli_catalog', 'cli_command', 'inspect_cli_command']);
+const READ_ONLY_AUTONOMY_ACTIONS = new Set(['', 'intake', 'request', 'route', 'plan', 'triage', 'autonomy_intake', 'queue', 'list', 'work', 'ongoing', 'autonomy_queue', 'item', 'card', 'show', 'inspect', 'autonomy_queue_item', 'status', 'summary', 'overview']);
+const READ_ONLY_DELEGATION_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'policy', 'decision', 'decisions', 'delegation_posture', 'routes', 'list', 'catalog', 'posture', 'route', 'item', 'card', 'show', 'inspect', 'delegation_route']);
+const READ_ONLY_EXECUTION_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'routes', 'posture', 'execution_posture', 'route', 'show_route', 'inspect_route', 'execution_route', 'history', 'activity', 'records', 'execution_history', 'record', 'item', 'show', 'inspect', 'execution_history_item', 'processes', 'background', 'backgrounds', 'background_processes', 'capabilities', 'process_capabilities', 'process', 'background_process', 'recovery', 'file_recovery', 'undo_redo']);
 
 type MarkedPermissionManager = PermissionManagerLike & { [SAFETY_MARKER]?: true };
 
@@ -47,9 +89,11 @@ export function installPermissionManagerSafetyGuard(manager: PermissionManagerLi
 
   manager.getCategory = (toolName, args = {}) => {
     try {
-      return originalGetCategory(toolName, args);
+      const category = originalGetCategory(toolName, args);
+      const knownCategory = fallbackPermissionCategoryForArgs(toolName, args);
+      return category === 'delegate' && knownCategory !== 'delegate' ? knownCategory : category;
     } catch {
-      return fallbackPermissionCategory(toolName);
+      return fallbackPermissionCategoryForArgs(toolName, args);
     }
   };
 
@@ -57,7 +101,7 @@ export function installPermissionManagerSafetyGuard(manager: PermissionManagerLi
     try {
       return await originalCheck(toolName, args);
     } catch {
-      return fallbackPermissionCategory(toolName) === 'read';
+      return fallbackPermissionCategoryForArgs(toolName, args) === 'read';
     }
   };
 
@@ -66,7 +110,7 @@ export function installPermissionManagerSafetyGuard(manager: PermissionManagerLi
       try {
         return await originalCheckDetailed(toolName, args);
       } catch (error) {
-        const category = fallbackPermissionCategory(toolName);
+        const category = fallbackPermissionCategoryForArgs(toolName, args);
         const approved = category === 'read';
         return {
           approved,
@@ -91,3 +135,153 @@ export function fallbackPermissionCategory(toolName: string): PermissionCategory
   if (EXECUTE_TOOL_NAMES.has(toolName)) return 'execute';
   return 'delegate';
 }
+
+export function fallbackPermissionCategoryForArgs(toolName: string, args: Record<string, unknown>): PermissionCategory {
+  if (toolName === 'process') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase()
+      : typeof args.processAction === 'string'
+        ? args.processAction.trim().toLowerCase()
+        : '';
+    return READ_ONLY_PROCESS_ACTIONS.has(action) ? 'read' : 'execute';
+  }
+  if (toolName === 'schedule') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase()
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase()
+        : '';
+    return READ_ONLY_SCHEDULE_ACTIONS.has(action) ? 'read' : 'execute';
+  }
+  if (toolName === 'import_goodvibes_settings') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase()
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase()
+        : '';
+    return READ_ONLY_SETTINGS_IMPORT_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'settings') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    const confirmed = args.confirm === true || (typeof args.confirm === 'string' && ['true', 'yes', 'apply', 'run'].includes(args.confirm.trim().toLowerCase()));
+    if ((action === 'import' || action === 'import_settings' || action === 'settings_import' || action === 'import_goodvibes' || action === 'goodvibes_import') && confirmed) return 'write';
+    return READ_ONLY_SETTINGS_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'setup') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_SETUP_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'vibe') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_VIBE_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'personal_ops') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_PERSONAL_OPS_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'research') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_RESEARCH_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'channels') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_CHANNELS_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'memory') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_MEMORY_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'computer') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_COMPUTER_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'device') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_DEVICE_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'models') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_MODELS_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'workspace') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_WORKSPACE_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'autonomy') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_AUTONOMY_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'delegation') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_DELEGATION_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'execution') {
+    const action = typeof args.action === 'string'
+      ? args.action.trim().toLowerCase().replace(/-/g, '_')
+      : typeof args.mode === 'string'
+        ? args.mode.trim().toLowerCase().replace(/-/g, '_')
+        : '';
+    return READ_ONLY_EXECUTION_ACTIONS.has(action) ? 'read' : 'write';
+  }
+  if (toolName === 'agent_artifacts') {
+    const mode = typeof args.mode === 'string' ? args.mode.trim() : '';
+    return mode === 'list' || mode === 'show' ? 'read' : 'write';
+  }
+  if (toolName === 'agent_review_packet_presets') {
+    const mode = typeof args.mode === 'string' ? args.mode.trim() : '';
+    return mode === 'list' || mode === 'show' || mode === '' ? 'read' : 'write';
+  }
+  return fallbackPermissionCategory(toolName);
+}