@pellux/goodvibes-agent 1.1.7 → 1.2.0

package/src/tools/agent-workspace-tool.ts

@@ -0,0 +1,305 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import type { CommandContext, CommandRegistry } from '../input/command-registry.ts';
+import { createAgentHarnessTool } from './agent-harness-tool.ts';
+
+type AgentWorkspaceToolAction =
+  | 'status'
+  | 'actions'
+  | 'action'
+  | 'run'
+  | 'surfaces'
+  | 'surface'
+  | 'open'
+  | 'panels'
+  | 'panel'
+  | 'open_panel'
+  | 'shortcuts'
+  | 'keybindings'
+  | 'keybinding'
+  | 'run_keybinding'
+  | 'set_keybinding'
+  | 'reset_keybinding'
+  | 'commands'
+  | 'command'
+  | 'run_command'
+  | 'cli_commands'
+  | 'cli_command';
+
+interface AgentWorkspaceToolArgs {
+  readonly action?: unknown;
+  readonly mode?: unknown;
+  readonly id?: unknown;
+  readonly actionId?: unknown;
+  readonly workspaceActionId?: unknown;
+  readonly surfaceId?: unknown;
+  readonly panelId?: unknown;
+  readonly command?: unknown;
+  readonly commandName?: unknown;
+  readonly args?: unknown;
+  readonly target?: unknown;
+  readonly query?: unknown;
+  readonly category?: unknown;
+  readonly categoryId?: unknown;
+  readonly recordId?: unknown;
+  readonly fields?: unknown;
+  readonly combo?: unknown;
+  readonly combos?: unknown;
+  readonly key?: unknown;
+  readonly value?: unknown;
+  readonly pane?: unknown;
+  readonly includeParameters?: unknown;
+  readonly limit?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+interface AgentWorkspaceToolDeps {
+  readonly commandRegistry: CommandRegistry;
+  readonly commandContext: CommandContext;
+  readonly toolRegistry: ToolRegistry;
+  readonly harnessTool?: Tool;
+}
+
+function error(message: string): { readonly success: false; readonly error: string } {
+  return { success: false, error: message };
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeWorkspaceAction(value: unknown): AgentWorkspaceToolAction | null {
+  const action = readString(value).toLowerCase().replace(/-/g, '_');
+  if (!action) return null;
+  if (action === 'status' || action === 'summary' || action === 'home' || action === 'workspace' || action === 'categories' || action === 'workspace_categories') return 'status';
+  if (action === 'actions' || action === 'list_actions' || action === 'workspace_actions' || action === 'tasks') return 'actions';
+  if (action === 'action' || action === 'show' || action === 'inspect' || action === 'workspace_action') return 'action';
+  if (action === 'run' || action === 'submit' || action === 'run_action' || action === 'run_workspace_action') return 'run';
+  if (action === 'surfaces' || action === 'ui_surfaces' || action === 'screens' || action === 'views') return 'surfaces';
+  if (action === 'surface' || action === 'ui_surface' || action === 'screen' || action === 'view') return 'surface';
+  if (action === 'open' || action === 'navigate' || action === 'open_surface' || action === 'open_ui_surface') return 'open';
+  if (action === 'panels' || action === 'panes') return 'panels';
+  if (action === 'panel' || action === 'pane') return 'panel';
+  if (action === 'open_panel' || action === 'open_pane') return 'open_panel';
+  if (action === 'shortcuts' || action === 'shortcut_help' || action === 'help') return 'shortcuts';
+  if (action === 'keybindings' || action === 'bindings' || action === 'keys') return 'keybindings';
+  if (action === 'keybinding' || action === 'binding' || action === 'key') return 'keybinding';
+  if (action === 'run_keybinding' || action === 'trigger_keybinding' || action === 'trigger_shortcut') return 'run_keybinding';
+  if (action === 'set_keybinding' || action === 'bind' || action === 'set_binding') return 'set_keybinding';
+  if (action === 'reset_keybinding' || action === 'unbind' || action === 'reset_binding') return 'reset_keybinding';
+  if (action === 'commands' || action === 'slash_commands' || action === 'command_catalog') return 'commands';
+  if (action === 'command' || action === 'slash_command' || action === 'inspect_command') return 'command';
+  if (action === 'run_command' || action === 'execute_command' || action === 'execute') return 'run_command';
+  if (action === 'cli_commands' || action === 'cli_catalog') return 'cli_commands';
+  if (action === 'cli_command' || action === 'inspect_cli_command') return 'cli_command';
+  return null;
+}
+
+function readAction(args: AgentWorkspaceToolArgs): AgentWorkspaceToolAction {
+  const explicit = normalizeWorkspaceAction(args.action) ?? normalizeWorkspaceAction(args.mode);
+  if (explicit) return explicit;
+  if (readString(args.surfaceId)) return 'surface';
+  if (readString(args.panelId)) return 'panel';
+  if (readString(args.actionId) || readString(args.workspaceActionId)) return 'action';
+  if (readString(args.command) || readString(args.commandName)) return 'command';
+  if (readString(args.key)) return 'keybinding';
+  if (readString(args.categoryId) || readString(args.category) || readString(args.query) || readString(args.target)) return 'actions';
+  return 'status';
+}
+
+function compactArgs(entries: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== undefined && value !== ''));
+}
+
+function lookupId(args: AgentWorkspaceToolArgs): string {
+  return readString(args.actionId) || readString(args.workspaceActionId) || readString(args.id);
+}
+
+function surfaceLookup(args: AgentWorkspaceToolArgs): string {
+  return readString(args.surfaceId) || readString(args.id);
+}
+
+function panelLookup(args: AgentWorkspaceToolArgs): string {
+  return readString(args.panelId) || readString(args.id);
+}
+
+function confirmedArgs(args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  return compactArgs({
+    confirm: args.confirm,
+    explicitUserRequest: args.explicitUserRequest,
+  });
+}
+
+function workspaceDiscoveryArgs(args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  return compactArgs({
+    category: args.category,
+    categoryId: args.categoryId,
+    target: args.target,
+    query: args.query,
+    limit: args.limit,
+    includeParameters: args.includeParameters,
+  });
+}
+
+function workspaceActionArgs(mode: 'workspace_action' | 'run_workspace_action', args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  const actionId = lookupId(args);
+  return compactArgs({
+    mode,
+    actionId,
+    command: args.command,
+    recordId: args.recordId,
+    fields: args.fields,
+    target: actionId || args.command ? undefined : args.target,
+    query: actionId || args.command ? undefined : args.query,
+    category: args.category,
+    categoryId: args.categoryId,
+    includeParameters: args.includeParameters,
+    ...(mode === 'run_workspace_action' ? confirmedArgs(args) : {}),
+  });
+}
+
+function surfaceArgs(mode: 'ui_surface' | 'open_ui_surface', args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  const surfaceId = surfaceLookup(args);
+  return compactArgs({
+    mode,
+    surfaceId,
+    category: args.category,
+    categoryId: args.categoryId,
+    target: surfaceId ? args.target : (args.target ?? args.query),
+    query: surfaceId ? undefined : args.query,
+    includeParameters: mode === 'ui_surface' ? args.includeParameters : undefined,
+    ...(mode === 'open_ui_surface' ? confirmedArgs(args) : {}),
+  });
+}
+
+function panelArgs(mode: 'panel' | 'open_panel', args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  const panelId = panelLookup(args);
+  return compactArgs({
+    mode,
+    panelId,
+    target: panelId ? undefined : args.target,
+    query: panelId ? undefined : args.query,
+    pane: args.pane,
+    includeParameters: mode === 'panel' ? args.includeParameters : undefined,
+    ...(mode === 'open_panel' ? confirmedArgs(args) : {}),
+  });
+}
+
+function keybindingArgs(mode: 'keybinding' | 'run_keybinding' | 'set_keybinding' | 'reset_keybinding', args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  const actionId = lookupId(args);
+  return compactArgs({
+    mode,
+    actionId,
+    target: actionId ? undefined : args.target,
+    query: actionId ? undefined : args.query,
+    key: args.key,
+    combo: args.combo,
+    combos: args.combos,
+    fields: args.fields,
+    value: args.value,
+    includeParameters: mode === 'keybinding' ? args.includeParameters : undefined,
+    ...(mode === 'run_keybinding' || mode === 'set_keybinding' || mode === 'reset_keybinding' ? confirmedArgs(args) : {}),
+  });
+}
+
+function commandArgs(mode: 'command' | 'run_command' | 'cli_command', args: AgentWorkspaceToolArgs): Record<string, unknown> {
+  return compactArgs({
+    mode,
+    command: args.command,
+    commandName: args.commandName,
+    args: args.args,
+    target: args.command || args.commandName ? undefined : args.target,
+    query: args.command || args.commandName ? undefined : args.query,
+    includeParameters: mode === 'run_command' ? undefined : args.includeParameters,
+    ...(mode === 'run_command' ? confirmedArgs(args) : {}),
+  });
+}
+
+export function createAgentWorkspaceTool(deps: AgentWorkspaceToolDeps): Tool {
+  const harnessTool = deps.harnessTool ?? createAgentHarnessTool({
+    commandRegistry: deps.commandRegistry,
+    commandContext: deps.commandContext,
+    toolRegistry: deps.toolRegistry,
+  });
+
+  return {
+    definition: {
+      name: 'workspace',
+      description: 'Inspect/open workspace actions, UI, commands, and keys.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['status', 'actions', 'action', 'run', 'surfaces', 'surface', 'open', 'panels', 'panel', 'open_panel', 'shortcuts', 'keybindings', 'keybinding', 'run_keybinding', 'set_keybinding', 'reset_keybinding', 'commands', 'command', 'run_command', 'cli_commands', 'cli_command'],
+            description: 'Inspect catalogs, open UI, or run approved workspace actions.',
+          },
+          mode: { type: 'string', description: 'Alias for action.' },
+          id: { type: 'string', description: 'Generic action, surface, panel, or keybinding id.' },
+          actionId: { type: 'string', description: 'Workspace action or keybinding action id.' },
+          workspaceActionId: { type: 'string', description: 'Workspace action id alias.' },
+          surfaceId: { type: 'string', description: 'UI surface id.' },
+          panelId: { type: 'string', description: 'Panel id.' },
+          command: { type: 'string', description: 'Slash or CLI command string.' },
+          commandName: { type: 'string', description: 'Slash or CLI command name.' },
+          args: { type: 'array', items: { type: 'string' }, description: 'Command arguments when commandName is used.' },
+          target: { type: 'string', description: 'Lookup target, UI target, or search text.' },
+          query: { type: 'string', description: 'Catalog search text.' },
+          category: { type: 'string', description: 'Workspace category filter.' },
+          categoryId: { type: 'string', description: 'Workspace category id.' },
+          recordId: { type: 'string', description: 'Selected local record id for workspace editors.' },
+          fields: { type: 'object', additionalProperties: { type: 'string' }, description: 'Workspace editor field values.' },
+          combo: { type: 'object', description: 'Single keybinding combo.' },
+          combos: { type: 'array', items: { type: 'object' }, description: 'Multiple keybinding combos.' },
+          key: { type: 'string', description: 'Keybinding lookup key.' },
+          value: { anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }], description: 'Keybinding value such as Ctrl+G.' },
+          pane: { type: 'string', enum: ['top', 'bottom'], description: 'Preferred pane for panel open.' },
+          includeParameters: { type: 'boolean', description: 'Include detailed schemas or route metadata.' },
+          limit: { type: 'number', description: 'Maximum rows returned for catalog actions.' },
+          confirm: { type: 'boolean', description: 'Required true for UI opens and side-effecting actions.' },
+          explicitUserRequest: { type: 'string', description: 'User request authorizing confirmed workspace effects.' },
+        },
+        additionalProperties: false,
+      },
+      sideEffects: ['state'],
+      concurrency: 'serial',
+    },
+    execute: async (rawArgs: unknown) => {
+      const args = (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs) ? rawArgs : {}) as AgentWorkspaceToolArgs;
+      const action = readAction(args);
+
+      if (action === 'status') return harnessTool.execute(compactArgs({ mode: 'workspace', target: args.target, query: args.query, includeParameters: args.includeParameters }));
+      if (action === 'actions') return harnessTool.execute({ mode: 'workspace_actions', ...workspaceDiscoveryArgs(args) });
+      if (action === 'action') return harnessTool.execute(workspaceActionArgs('workspace_action', args));
+      if (action === 'run') return harnessTool.execute(workspaceActionArgs('run_workspace_action', args));
+      if (action === 'surfaces') return harnessTool.execute(compactArgs({ mode: 'ui_surfaces', target: args.target, query: args.query, limit: args.limit, includeParameters: args.includeParameters }));
+      if (action === 'surface') return harnessTool.execute(surfaceArgs('ui_surface', args));
+      if (action === 'open') return harnessTool.execute(surfaceArgs('open_ui_surface', args));
+      if (action === 'panels') return harnessTool.execute(compactArgs({ mode: 'panels', target: args.target, query: args.query, limit: args.limit, includeParameters: args.includeParameters }));
+      if (action === 'panel') return harnessTool.execute(panelArgs('panel', args));
+      if (action === 'open_panel') return harnessTool.execute(panelArgs('open_panel', args));
+      if (action === 'shortcuts') return harnessTool.execute(compactArgs({ mode: 'shortcuts', target: args.target, query: args.query, limit: args.limit, includeParameters: args.includeParameters }));
+      if (action === 'keybindings') return harnessTool.execute(compactArgs({ mode: 'keybindings', target: args.target, query: args.query, limit: args.limit, includeParameters: args.includeParameters }));
+      if (action === 'keybinding') return harnessTool.execute(keybindingArgs('keybinding', args));
+      if (action === 'run_keybinding') return harnessTool.execute(keybindingArgs('run_keybinding', args));
+      if (action === 'set_keybinding') return harnessTool.execute(keybindingArgs('set_keybinding', args));
+      if (action === 'reset_keybinding') return harnessTool.execute(keybindingArgs('reset_keybinding', args));
+      if (action === 'commands') return harnessTool.execute(compactArgs({ mode: 'commands', target: args.target, query: args.query, limit: args.limit, includeParameters: args.includeParameters }));
+      if (action === 'command') return harnessTool.execute(commandArgs('command', args));
+      if (action === 'run_command') return harnessTool.execute(commandArgs('run_command', args));
+      if (action === 'cli_commands') return harnessTool.execute(compactArgs({ mode: 'cli_commands', target: args.target, query: args.query, limit: args.limit, includeParameters: args.includeParameters }));
+      if (action === 'cli_command') return harnessTool.execute(commandArgs('cli_command', args));
+
+      return error('Unknown workspace action. Use action:"status" or action:"actions" to inspect the workspace.');
+    },
+  };
+}
+
+export function registerAgentWorkspaceTool(
+  registry: ToolRegistry,
+  commandRegistry: CommandRegistry,
+  commandContext: CommandContext,
+): void {
+  if (!registry.has('workspace')) registry.register(createAgentWorkspaceTool({ commandRegistry, commandContext, toolRegistry: registry }));
+}

package/src/tools/artifact-archive.ts

@@ -0,0 +1,169 @@
+import { deflateRawSync } from 'node:zlib';
+import type { ArtifactDescriptor } from '@pellux/goodvibes-sdk/platform/artifacts';
+
+export interface ArtifactPackageEntry {
+  readonly path: string;
+  readonly buffer: Buffer;
+}
+
+const SENSITIVE_METADATA_KEY = /token|secret|password|authorization|credential|api[-_]?key/i;
+
+export function sanitizeArtifactMetadata(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sanitizeArtifactMetadata);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+    key,
+    SENSITIVE_METADATA_KEY.test(key) ? '<redacted>' : sanitizeArtifactMetadata(entry),
+  ]));
+}
+
+export function sanitizeArtifactSourceUri(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  try {
+    const url = new URL(value);
+    for (const key of [...url.searchParams.keys()]) {
+      if (SENSITIVE_METADATA_KEY.test(key)) url.searchParams.set(key, '<redacted>');
+    }
+    return url.toString();
+  } catch {
+    return value.replace(/([?&\s](?:token|secret|password|authorization|credential|api[-_]?key)=)[^\s&]+/gi, '$1<redacted>');
+  }
+}
+
+export function safeArtifactExportFilename(artifact: ArtifactDescriptor): string {
+  const filename = (artifact.filename || artifact.id).trim() || artifact.id;
+  return filename.replace(/[\\/]+/g, '-').replace(/^\.+$/, artifact.id);
+}
+
+function safePackagePathSegment(value: string, fallback: string): string {
+  const sanitized = value
+    .replace(/[\\/]+/g, '-')
+    .replace(/[<>:"|?*\x00-\x1F]+/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/^\.+$/, '');
+  const normalized = sanitized || fallback;
+  return normalized.length > 128 ? normalized.slice(0, 128).trimEnd() : normalized;
+}
+
+export function packageArtifactFilename(
+  artifact: ArtifactDescriptor,
+  index: number,
+  used: Set<string>,
+): string {
+  const ordinal = String(index + 1).padStart(2, '0');
+  const id = safePackagePathSegment(artifact.id, `artifact-${ordinal}`);
+  const filename = safePackagePathSegment(safeArtifactExportFilename(artifact), id);
+  const base = `${ordinal}-${id}-${filename}`;
+  let candidate = base;
+  let suffix = 2;
+  while (used.has(candidate.toLowerCase())) {
+    candidate = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  used.add(candidate.toLowerCase());
+  return candidate;
+}
+
+function createCrc32Table(): Uint32Array {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < table.length; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value & 1) !== 0 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+}
+
+const CRC32_TABLE = createCrc32Table();
+
+function crc32(buffer: Buffer): number {
+  let crc = 0xffffffff;
+  for (const byte of buffer) {
+    crc = CRC32_TABLE[(crc ^ byte) & 0xff]! ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function dosTimestamp(date = new Date()): { readonly time: number; readonly date: number } {
+  const year = Math.max(1980, Math.min(2107, date.getFullYear()));
+  return {
+    time: (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+    date: ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+  };
+}
+
+export function createZipArchive(entries: readonly ArtifactPackageEntry[]): Buffer {
+  if (entries.length > 0xffff) throw new Error('Artifact archive has too many files for ZIP output.');
+  const localParts: Buffer[] = [];
+  const centralParts: Buffer[] = [];
+  const timestamp = dosTimestamp();
+  let offset = 0;
+
+  for (const entry of entries) {
+    const safePath = entry.path.replace(/\\/g, '/');
+    const name = Buffer.from(safePath, 'utf-8');
+    const compressed = deflateRawSync(entry.buffer);
+    if (name.byteLength > 0xffff) throw new Error(`Artifact archive entry path is too long: ${safePath}`);
+    if (entry.buffer.byteLength > 0xffffffff || compressed.byteLength > 0xffffffff) {
+      throw new Error(`Artifact archive entry is too large for ZIP output: ${safePath}`);
+    }
+    const checksum = crc32(entry.buffer);
+    const method = 8;
+
+    const localHeader = Buffer.alloc(30);
+    localHeader.writeUInt32LE(0x04034b50, 0);
+    localHeader.writeUInt16LE(20, 4);
+    localHeader.writeUInt16LE(0, 6);
+    localHeader.writeUInt16LE(method, 8);
+    localHeader.writeUInt16LE(timestamp.time, 10);
+    localHeader.writeUInt16LE(timestamp.date, 12);
+    localHeader.writeUInt32LE(checksum, 14);
+    localHeader.writeUInt32LE(compressed.byteLength, 18);
+    localHeader.writeUInt32LE(entry.buffer.byteLength, 22);
+    localHeader.writeUInt16LE(name.byteLength, 26);
+    localHeader.writeUInt16LE(0, 28);
+    localParts.push(localHeader, name, compressed);
+
+    const centralHeader = Buffer.alloc(46);
+    centralHeader.writeUInt32LE(0x02014b50, 0);
+    centralHeader.writeUInt16LE(20, 4);
+    centralHeader.writeUInt16LE(20, 6);
+    centralHeader.writeUInt16LE(0, 8);
+    centralHeader.writeUInt16LE(method, 10);
+    centralHeader.writeUInt16LE(timestamp.time, 12);
+    centralHeader.writeUInt16LE(timestamp.date, 14);
+    centralHeader.writeUInt32LE(checksum, 16);
+    centralHeader.writeUInt32LE(compressed.byteLength, 20);
+    centralHeader.writeUInt32LE(entry.buffer.byteLength, 24);
+    centralHeader.writeUInt16LE(name.byteLength, 28);
+    centralHeader.writeUInt16LE(0, 30);
+    centralHeader.writeUInt16LE(0, 32);
+    centralHeader.writeUInt16LE(0, 34);
+    centralHeader.writeUInt16LE(0, 36);
+    centralHeader.writeUInt32LE(0, 38);
+    centralHeader.writeUInt32LE(offset, 42);
+    centralParts.push(centralHeader, name);
+
+    offset += localHeader.byteLength + name.byteLength + compressed.byteLength;
+    if (offset > 0xffffffff) throw new Error('Artifact archive is too large for ZIP output.');
+  }
+
+  const centralOffset = offset;
+  const centralDirectory = Buffer.concat(centralParts);
+  if (centralDirectory.byteLength > 0xffffffff) throw new Error('Artifact archive central directory is too large for ZIP output.');
+
+  const endOfCentralDirectory = Buffer.alloc(22);
+  endOfCentralDirectory.writeUInt32LE(0x06054b50, 0);
+  endOfCentralDirectory.writeUInt16LE(0, 4);
+  endOfCentralDirectory.writeUInt16LE(0, 6);
+  endOfCentralDirectory.writeUInt16LE(entries.length, 8);
+  endOfCentralDirectory.writeUInt16LE(entries.length, 10);
+  endOfCentralDirectory.writeUInt32LE(centralDirectory.byteLength, 12);
+  endOfCentralDirectory.writeUInt32LE(centralOffset, 16);
+  endOfCentralDirectory.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...localParts, centralDirectory, endOfCentralDirectory]);
+}

package/src/tools/tool-definition-compaction.ts

@@ -5,41 +5,77 @@ const DEFAULT_TOOL_DESCRIPTION_LIMIT = 56;
 
 const TOOL_DESCRIPTION_OVERRIDES: Readonly<Record<string, string>> = {
   agent: 'Inspect explicit subagent tasks.',
+  audit: 'Inspect release readiness and evidence.',
   analyze: 'Analyze code impact, symbols, and project risk.',
+  autonomy: 'Route ongoing work and inspect visible autonomy.',
   channel: 'Inspect or operate configured channel surfaces.',
+  channels: 'Inspect channel readiness, setup, triage, and receipts.',
+  computer: 'Inspect/open browser, desktop, and computer routes.',
+  context: 'Inspect project instructions and prompt context.',
+  delegation: 'Inspect build delegation routes and policy.',
   control: 'Inspect commands, panels, and runtime posture.',
+  device: 'Inspect/open device, voice, and browser routes.',
+  execution: 'Inspect local work routes, history, and recovery.',
   edit: 'Edit files with exact, fuzzy, or regex replacements.',
   exec: 'Run shell commands with timeout and retry.',
   fetch: 'Fetch HTTP URLs with auth and sanitization.',
   find: 'Search files, content, symbols, and project structure.',
   goodvibes_context: 'Inspect current GoodVibes runtime and host harness.',
   goodvibes_settings: 'Inspect/update GoodVibes settings on explicit request.',
+  host: 'Inspect GoodVibes host status, services, and methods.',
+  import_goodvibes_settings: 'Preview/apply shared GoodVibes settings import.',
   inspect: 'Inspect project structure, APIs, routes, and deps.',
   mcp: 'Inspect MCP servers, tools, schemas, and trust state.',
+  memory: 'Inspect memory posture, providers, curator, records.',
+  models: 'Inspect model routes, providers, cookbook, and checks.',
   packet: 'Manage implementation and execution packets.',
+  personal_ops: 'Brief, route, inspect, and read Personal Ops.',
   query: 'Track operator queries, answers, and closure.',
   read: 'Read files, outlines, symbols, and ranges.',
+  research: 'Plan, track, source, and save research.',
   registry: 'Discover local skills, agents, tools, and templates.',
   remote: 'Manage remote runner pools and artifacts.',
   repl: 'Evaluate bounded JS, TS, Python, SQL, or GraphQL.',
+  route: 'Choose the best visible route for a user task.',
+  schedule: 'List, create, edit, run, pause, resume schedules.',
+  security: 'Read security posture, findings, and policy decisions.',
+  sessions: 'Search and inspect saved sessions/bookmarks.',
+  settings: 'List, inspect, change, reset, or import settings.',
+  setup: 'Inspect and complete first-run Agent setup.',
+  support: 'Inspect support bundle routes and redacted bundles.',
   state: 'Read/update session state and diagnostics.',
   task: 'Manage cross-session tasks and handoffs.',
   team: 'Manage team definitions, roles, and lanes.',
+  terminal: 'Start visible tracked background shell commands.',
+  vibe: 'Inspect/create/import VIBE.md personality.',
+  workspace: 'Inspect/open workspace actions, UI, commands, keys.',
   web_search: 'Search the web through the configured provider.',
   workflow: 'Inspect/control configured workflow automation.',
   worklist: 'Manage durable worklists and checklist items.',
   write: 'Write files with batch, mkdir, backup, and validation.',
+  process: 'List, poll, log, wait, stop tracked processes.',
   agent_harness: 'Harness catalog: modes, settings, commands, UI, tools.',
+  agent_artifacts: 'Browse, preview, export, package, and archive artifacts.',
+  agent_documents: 'Create drafts, comments, suggestions, artifact attach/insert, and exports.',
   agent_knowledge: 'Read isolated Agent Knowledge.',
   agent_knowledge_ingest: 'Ingest confirmed source into Agent Knowledge.',
+  agent_learning_consolidation: 'Apply confirmed local duplicate learning phases.',
   agent_local_registry: 'Inspect/update Agent memory, notes, skills, routines.',
   agent_work_plan: 'Inspect/update the visible Agent-local work plan.',
   agent_operator_briefing: 'Read connected Agent operator state.',
   agent_operator_action: 'Run one confirmed allowlisted operator action.',
+  agent_autonomy_schedule: 'Schedule one confirmed autonomous Agent task.',
+  agent_schedule_edit: 'Edit one confirmed connected schedule.',
+  agent_research_runs: 'Track visible local research run checkpoints.',
+  agent_research_sources: 'Manage local research source review queue.',
+  agent_research_report: 'Save one confirmed sourced research report artifact.',
   agent_reminder_schedule: 'Schedule one confirmed Agent reminder.',
   agent_channel_send: 'Send confirmed message to configured Agent target.',
   agent_notify: 'Send one confirmed plain-text notification.',
   agent_media_generate: 'Generate one confirmed image or video artifact.',
+  agent_review_packet_presets: 'Save/list/refresh Document Ops packet presets.',
+  agent_review_packet_share: 'Share confirmed review packet archive reference.',
+  agent_model_compare: 'Blind compare prompts/artifacts, review, route receipts, handoff, diff.',
 };
 
 function compactText(value: string, limit: number): string {

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.1.7';
+let _version = '1.2.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;