@pellux/goodvibes-agent 0.1.116 → 1.0.0

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

@@ -1,14 +1,13 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
-import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
 import type { OAuthProviderConfig, ProviderSubscription } from '@pellux/goodvibes-sdk/platform/config';
 import { getSubscriptionProviderConfig, listAvailableSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { inspectProviderAuth } from '@/runtime/index.ts';
+import { formatAgentRecordSource } from '../../agent/record-labels.ts';
 import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireSecretsManager, requireServiceRegistry, requireShellPaths, requireSubscriptionManager } from './runtime-services.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface SubscriptionBundle {
@@ -24,13 +23,13 @@ function buildReviewText(ctx: CommandContext): string {
     return [
       'Subscription Review',
       '  No provider subscriptions stored yet.',
-      ...(available.length > 0 ? [`  available providers: ${available.map((entry) => entry.provider).join(', ')}`] : []),
+      ...(available.length > 0 ? [`  available providers ${available.map((entry) => entry.provider).join(', ')}`] : []),
     ].join('\n');
   }
   return [
     `Subscription Review`,
     ...subscriptions.map((subscription) => (
-      `  ${subscription.provider}  ${subscription.authMode}  token=${subscription.tokenType}  expires=${subscription.expiresAt ? new Date(subscription.expiresAt).toISOString() : 'n/a'}`
+      `  ${subscription.provider}  auth mode ${subscription.authMode}  token ${subscription.tokenType}  expires ${subscription.expiresAt ? new Date(subscription.expiresAt).toISOString() : 'n/a'}`
     )),
   ].join('\n');
 }
@@ -39,8 +38,8 @@ function inspectBundle(path: string): string {
   const bundle = JSON.parse(readFileSync(path, 'utf-8')) as SubscriptionBundle;
   return [
     'Subscription Bundle Review',
-    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
-    `  subscriptions: ${bundle.subscriptions.length}`,
+    `  exported at ${new Date(bundle.exportedAt).toISOString()}`,
+    `  subscriptions ${bundle.subscriptions.length}`,
     ...bundle.subscriptions.map((subscription) => `  ${subscription.provider}  ${subscription.authMode}`),
   ].join('\n');
 }
@@ -57,19 +56,16 @@ function extractAuthorizationCode(input: string): string | null {
   }
 }
 
-function resolveLoginConfig(config: OAuthProviderConfig, useLocalCallback: boolean): OAuthProviderConfig {
-  if (!useLocalCallback || !config.localCallback) {
-    return config.manualRedirectUri
-      ? { ...config, redirectUri: config.manualRedirectUri }
-      : config;
-  }
-  return config;
+function resolveManualLoginConfig(config: OAuthProviderConfig): OAuthProviderConfig {
+  return config.manualRedirectUri
+    ? { ...config, redirectUri: config.manualRedirectUri }
+    : config;
 }
 
 function describePrecedence(record: Pick<ProviderSubscription, 'overrideAmbientApiKeys'>): string {
   return record.overrideAmbientApiKeys
-    ? '  precedence: this now overrides ambient API keys for the provider'
-    : '  precedence: stored for subscription-backed flows only; ambient API keys are unchanged';
+    ? '  precedence this now overrides ambient API keys for the provider'
+    : '  precedence stored for subscription-backed flows only; ambient API keys are unchanged';
 }
 
 export function registerSubscriptionRuntimeCommands(registry: CommandRegistry): void {
@@ -77,15 +73,10 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
     name: 'subscription',
     aliases: ['subs'],
     description: 'Manage provider subscription sessions and, when supported, let them override ambient API keys for matching providers',
-    usage: '[review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual] --yes|login <provider> finish <code-or-url> --yes|logout <provider> --yes|bundle export <path> --yes|bundle inspect <path>]',
+    usage: '[review|list|providers|inspect <provider>|login <provider> start [--no-browser] --yes|login <provider> finish <code-or-url> --yes|logout <provider> --yes|bundle export <path> --yes|bundle inspect <path>]',
     async handler(args, ctx) {
       const parsed = stripYesFlag(args);
       const commandArgs = [...parsed.rest];
-      const shellPaths = requireShellPaths(ctx);
-      if (args.length === 0 && ctx.openSubscriptionPanel) {
-        ctx.openSubscriptionPanel();
-        return;
-      }
       const sub = (commandArgs[0] ?? 'review').toLowerCase();
       const manager = requireSubscriptionManager(ctx);
       const services = requireServiceRegistry(ctx);
@@ -104,7 +95,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
         ctx.print([
           'Available Subscription Providers',
           ...available.map((provider) => (
-            `  ${provider.provider}  source=${provider.source}  redirect=${provider.oauth.redirectUri}`
+            `  ${provider.provider}  origin ${formatAgentRecordSource(provider.source)}  redirect ${provider.oauth.redirectUri}`
           )),
         ].join('\n'));
         return;
@@ -128,29 +119,28 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
         });
         ctx.print([
           `Subscription ${provider}`,
-          `  configured: ${inspection.configured ? 'yes' : 'no'}`,
-          `  freshness: ${inspection.freshness}`,
-          `  callbackMode: ${inspection.callbackMode}`,
+          `  configured ${inspection.configured ? 'yes' : 'no'}`,
+          `  freshness ${inspection.freshness}`,
+          '  finish mode explicit manual',
           ...(resolved ? [
-            `  source: ${resolved.source}`,
-            `  redirectUri: ${resolved.oauth.redirectUri}`,
-            `  authUrl: ${resolved.oauth.authUrl}`,
-            `  tokenUrl: ${resolved.oauth.tokenUrl}`,
-            ...(inspection.localCallback ? [`  localCallback: ${inspection.localCallback}`] : []),
+            `  origin ${formatAgentRecordSource(resolved.source)}`,
+            `  redirect URI ${resolved.oauth.redirectUri}`,
+            `  auth URL ${resolved.oauth.authUrl}`,
+            `  token URL ${resolved.oauth.tokenUrl}`,
           ] : []),
           ...(inspection.activeSubscription ? [
-            `  authMode: ${manager.get(provider)?.authMode ?? 'oauth'}`,
-            `  tokenType: ${inspection.tokenType ?? 'n/a'}`,
-            `  createdAt: ${manager.get(provider)?.createdAt ? new Date(manager.get(provider)!.createdAt).toISOString() : 'n/a'}`,
-            `  updatedAt: ${manager.get(provider)?.updatedAt ? new Date(manager.get(provider)!.updatedAt).toISOString() : 'n/a'}`,
-            `  expiresAt: ${inspection.expiresAt ? new Date(inspection.expiresAt).toISOString() : 'n/a'}`,
-            `  refreshToken: ${manager.get(provider)?.refreshToken ? 'present' : 'absent'}`,
+            `  auth mode ${manager.get(provider)?.authMode ?? 'oauth'}`,
+            `  token type ${inspection.tokenType ?? 'n/a'}`,
+            `  created at ${manager.get(provider)?.createdAt ? new Date(manager.get(provider)!.createdAt).toISOString() : 'n/a'}`,
+            `  updated at ${manager.get(provider)?.updatedAt ? new Date(manager.get(provider)!.updatedAt).toISOString() : 'n/a'}`,
+            `  expires at ${inspection.expiresAt ? new Date(inspection.expiresAt).toISOString() : 'n/a'}`,
+            `  refresh token ${manager.get(provider)?.refreshToken ? 'present' : 'absent'}`,
             describePrecedence(manager.get(provider)!),
           ] : [
-            `  state: ${inspection.freshness === 'pending' ? 'pending login' : 'available for login'}`,
+            `  state ${inspection.freshness === 'pending' ? 'pending login' : 'available for login'}`,
           ]),
-          ...inspection.issues.map((issue) => `  issue: ${issue}`),
-          ...inspection.nextActions.map((action) => `  next: ${action}`),
+          ...inspection.issues.map((issue) => `  issue ${issue}`),
+          ...inspection.nextActions.map((action) => `  next ${action}`),
         ].join('\n'));
         return;
       }
@@ -179,7 +169,6 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
         if (mode === 'start') {
           const flags = new Set(commandArgs.slice(3));
           const openBrowser = !flags.has('--no-browser');
-          const useManualMode = flags.has('--manual');
           if (provider === 'openai' && resolved.source === 'builtin') {
             const started = await beginOpenAICodexLogin();
             manager.savePending({
@@ -190,158 +179,38 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
               createdAt: Date.now(),
             });
 
-            let listener: Awaited<ReturnType<typeof createOAuthLocalListener>> | null = null;
-            if (!useManualMode) {
-              try {
-                listener = await createOAuthLocalListener({
-                  expectedState: started.state,
-                  host: '127.0.0.1',
-                  port: 1455,
-                  path: '/auth/callback',
-                }).catch(() => null); // best-effort: listener creation is optional; null triggers manual flow
-              } catch {
-                listener = null;
-              }
-            }
-
             const browserOpened = openBrowser
               ? await openExternalUrl(started.authorizationUrl)
               : false;
 
-            if (listener && browserOpened) {
-              try {
-                const callback = await listener.waitForCode();
-                const token = await exchangeOpenAICodexCode(callback.code, started.verifier);
-                const now = Date.now();
-                const record = manager.saveSubscription({
-                  provider,
-                  accessToken: token.accessToken,
-                  refreshToken: token.refreshToken,
-                  tokenType: token.tokenType,
-                  expiresAt: token.expiresAt,
-                  ...(token.scopes ? { scopes: token.scopes } : {}),
-                  authMode: 'oauth',
-                  overrideAmbientApiKeys: false,
-                  createdAt: manager.get(provider)?.createdAt ?? now,
-                  updatedAt: now,
-                });
-                ctx.print([
-                  `Subscription OAuth Start: ${provider}`,
-                  `  source: ${resolved.source}`,
-                  `  state: ${started.state}`,
-                  `  redirectUri: ${started.redirectUri}`,
-                  `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-                  '  authorizationUrl:',
-                  `  ${started.authorizationUrl}`,
-                  `Subscription OAuth Complete: ${provider}`,
-                  `  tokenType: ${record.tokenType}`,
-                  `  expiresAt: ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
-                  describePrecedence(record),
-                ].join('\n'));
-                return;
-              } catch (error) {
-                listener.close();
-                ctx.print([
-                  `Subscription OAuth Start: ${provider}`,
-                  `  source: ${resolved.source}`,
-                  `  state: ${started.state}`,
-                  `  redirectUri: ${started.redirectUri}`,
-                  `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-                  `  next: /subscription login ${provider} finish <code-or-url> --yes`,
-                  `  listener: ${summarizeError(error)}`,
-                  '  authorizationUrl:',
-                  `  ${started.authorizationUrl}`,
-                ].join('\n'));
-                return;
-              }
-            }
-
-            listener?.close();
             ctx.print([
-              `Subscription OAuth Start: ${provider}`,
-              `  source: ${resolved.source}`,
-              `  state: ${started.state}`,
-              `  redirectUri: ${started.redirectUri}`,
-              `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-              `  next: /subscription login ${provider} finish <code-or-url> --yes`,
-              '  authorizationUrl:',
+              `Subscription OAuth start ${provider}`,
+              `  origin ${formatAgentRecordSource(resolved.source)}`,
+              `  state ${started.state}`,
+              `  redirect URI ${started.redirectUri}`,
+              `  browser ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
+              '  completion paste the callback code or redirect URL into the finish command',
+              `  next /subscription login ${provider} finish <code-or-url> --yes`,
+              '  authorization URL',
               `  ${started.authorizationUrl}`,
             ].join('\n'));
             return;
           }
-          const useLocalCallback = Boolean(resolved.oauth.localCallback) && !flags.has('--manual');
-          let activeConfig = resolveLoginConfig(resolved.oauth, useLocalCallback);
-          let listener: Awaited<ReturnType<typeof createOAuthLocalListener>> | null = null;
-
-          if (useLocalCallback && resolved.oauth.localCallback) {
-            listener = await createOAuthLocalListener({
-              expectedState: '',
-              host: resolved.oauth.localCallback.host,
-              port: resolved.oauth.localCallback.port,
-              path: resolved.oauth.localCallback.path,
-            }).catch(() => null); // best-effort: local callback listener is optional; null falls back to manual redirect
-          }
-
-          if (listener) {
-            activeConfig = { ...activeConfig, redirectUri: listener.redirectUri };
-          }
-
+          const activeConfig = resolveManualLoginConfig(resolved.oauth);
           const started = await manager.beginOAuthLogin(provider, activeConfig);
-          if (listener) {
-            listener.setExpectedState(started.pending.state);
-          }
-
           const browserOpened = openBrowser
-              ? await openExternalUrl(started.authorizationUrl)
-              : false;
-
-          const shouldAutoComplete = Boolean(listener) && (resolved.oauth.localCallback?.autoComplete ?? true) && browserOpened;
-
-          if (shouldAutoComplete && listener) {
-            try {
-              const callback = await listener.waitForCode();
-              const record = await manager.completeOAuthLogin(provider, activeConfig, callback.code);
-              ctx.print([
-                `Subscription OAuth Start: ${provider}`,
-                `  source: ${resolved.source}`,
-                `  state: ${started.pending.state}`,
-                `  redirectUri: ${activeConfig.redirectUri}`,
-                `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-                '  authorizationUrl:',
-                `  ${started.authorizationUrl}`,
-                `Subscription OAuth Complete: ${provider}`,
-                `  tokenType: ${record.tokenType}`,
-                `  expiresAt: ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
-                describePrecedence(record),
-              ].join('\n'));
-              return;
-            } catch (error) {
-              listener.close();
-              ctx.print([
-                `Subscription OAuth Start: ${provider}`,
-                `  source: ${resolved.source}`,
-                `  state: ${started.pending.state}`,
-                `  redirectUri: ${activeConfig.redirectUri}`,
-                `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-                `  next: /subscription login ${provider} finish <code-or-url> --yes`,
-                `  listener: ${summarizeError(error)}`,
-                '  authorizationUrl:',
-                `  ${started.authorizationUrl}`,
-              ].join('\n'));
-              return;
-            }
-          }
-
-          listener?.close();
+            ? await openExternalUrl(started.authorizationUrl)
+            : false;
 
           ctx.print([
-            `Subscription OAuth Start: ${provider}`,
-            `  source: ${resolved.source}`,
-            `  state: ${started.pending.state}`,
-            `  redirectUri: ${activeConfig.redirectUri}`,
-            `  browser: ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
-            `  next: /subscription login ${provider} finish <code-or-url> --yes`,
-            '  authorizationUrl:',
+            `Subscription OAuth start ${provider}`,
+            `  origin ${formatAgentRecordSource(resolved.source)}`,
+            `  state ${started.pending.state}`,
+            `  redirect URI ${activeConfig.redirectUri}`,
+            `  browser ${openBrowser ? (browserOpened ? 'opened' : 'open failed') : 'skipped'}`,
+            '  completion paste the callback code or redirect URL into the finish command',
+            `  next /subscription login ${provider} finish <code-or-url> --yes`,
+            '  authorization URL',
             `  ${started.authorizationUrl}`,
           ].join('\n'));
           return;
@@ -375,18 +244,18 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
             });
             ctx.print([
               `Stored subscription session for ${provider}.`,
-              `  tokenType: ${record.tokenType}`,
-              `  expiresAt: ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
+              `  token type ${record.tokenType}`,
+              `  expires at ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
               describePrecedence(record),
             ].join('\n'));
             return;
           }
-          const activeConfig = resolveLoginConfig(resolved.oauth, false);
+          const activeConfig = resolveManualLoginConfig(resolved.oauth);
           const record = await manager.completeOAuthLogin(provider, activeConfig, code);
           ctx.print([
             `Stored subscription session for ${provider}.`,
-            `  tokenType: ${record.tokenType}`,
-            `  expiresAt: ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
+            `  token type ${record.tokenType}`,
+            `  expires at ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
             describePrecedence(record),
           ].join('\n'));
           return;
@@ -419,7 +288,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
           ctx.print('Usage: /subscription bundle <export|inspect> <path>');
           return;
         }
-        const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+        const targetPath = requireShellPaths(ctx).resolveWorkspacePath(pathArg);
         if (mode === 'export') {
           if (!parsed.yes) {
             requireYesFlag(ctx, `export subscription bundle to ${pathArg}`, '/subscription bundle export <path> --yes');

package/src/input/commands/support-bundle-runtime.ts

@@ -0,0 +1,53 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import type { CliCommandRuntime } from '../../cli/management.ts';
+import { handleBundleCommand } from '../../cli/bundle-command.ts';
+import { parseGoodVibesCli } from '../../cli/parser.ts';
+import { requireShellPaths } from './runtime-services.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+
+function bundleUsageFor(subcommand: string | undefined): string {
+  if (subcommand === 'export') return '/bundle export [path] --yes';
+  if (subcommand === 'import') return '/bundle import <path> --yes';
+  if (subcommand === 'inspect') return '/bundle inspect <path>';
+  return '/bundle [export [path] --yes|inspect <path>|import <path> --yes]';
+}
+
+function bundleActionFor(subcommand: string): string | null {
+  if (subcommand === 'export') return 'export Agent support bundle';
+  if (subcommand === 'import') return 'import Agent support bundle';
+  return null;
+}
+
+export function registerSupportBundleRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'bundle',
+    description: 'Export, inspect, or import redacted Agent support bundles from the TUI',
+    usage: '[export [path] --yes|inspect <path>|import <path> --yes]',
+    argsHint: 'export|inspect|import',
+    async handler(args, ctx) {
+      const confirmation = stripYesFlag(args);
+      const cli = parseGoodVibesCli(['bundle', ...confirmation.rest], 'goodvibes-agent');
+      if (cli.errors.length > 0) {
+        ctx.print(cli.errors.join('\n'));
+        return;
+      }
+
+      const subcommand = cli.commandArgs[0] ?? 'inspect';
+      const guardedAction = bundleActionFor(subcommand);
+      if (guardedAction !== null && !confirmation.yes) {
+        requireYesFlag(ctx, guardedAction, bundleUsageFor(subcommand));
+        return;
+      }
+
+      const shellPaths = requireShellPaths(ctx);
+      const runtime: CliCommandRuntime = {
+        cli,
+        configManager: ctx.platform.configManager,
+        workingDirectory: shellPaths.workingDirectory,
+        homeDirectory: shellPaths.homeDirectory,
+      };
+      const result = await handleBundleCommand(runtime);
+      ctx.print(result.output);
+    },
+  });
+}

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

@@ -16,10 +16,10 @@ const BLOCKED_TASK_MUTATIONS: ReadonlySet<string> = new Set([
 function printTaskMutationBlocked(print: (text: string) => void, subcommand: string): void {
   print([
     `Task mutation "${subcommand}" is blocked in GoodVibes Agent.`,
-    '  policy: connected-service tasks are read-only from the Agent TUI; normal work stays in the main conversation.',
-    '  durable tasks: use /workplan for visible planning and task tracking.',
-    '  build/fix/review: use /delegate <task> to hand explicit implementation work to GoodVibes TUI.',
-    '  result: no local task state was changed.',
+    '  policy connected-host tasks are read-only from the Agent TUI; normal work stays in the main conversation.',
+    '  durable tasks use /workplan for visible planning and task tracking.',
+    '  build/fix/review use /delegate <task> to hand explicit implementation work to GoodVibes TUI.',
+    '  result no local task state was changed.',
   ].join('\n'));
 }
 
@@ -51,12 +51,12 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'tasks',
     aliases: ['task'],
-    description: 'Inspect connected-service tasks without starting or mutating local background work',
+    description: 'Inspect connected-host tasks without starting or mutating local background work',
     usage: '[list [status|kind] | show <taskId> | output <taskId>]',
     handler(args, ctx) {
       const subcommand = args[0]?.toLowerCase() ?? 'list';
       if (subcommand === 'open' || subcommand === 'panel') {
-        ctx.print('Task panels are not part of the Agent workspace. Use /tasks list.');
+        ctx.print('Open Agent Workspace -> Work -> Host tasks for the workspace view, or run /tasks list for compact command output.');
         return;
       }
 
@@ -76,7 +76,7 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
           return;
         }
         ctx.print([
-          `Runtime Tasks (${filtered.length})`,
+          `Connected-host Tasks (${filtered.length})`,
           ...filtered.slice(0, 20).map((task) => `  ${task.id}  ${task.status.padEnd(9)} ${task.kind.padEnd(11)} ${task.owner}  ${task.title}`),
         ].join('\n'));
         return;
@@ -90,23 +90,23 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
         }
         const task = operatorClient.tasks.get(taskId);
         if (!task) {
-          ctx.print(`Unknown task: ${taskId}`);
+          ctx.print(`Unknown task ${taskId}`);
           return;
         }
         ctx.print([
           `Task ${task.id}`,
-          `  title: ${task.title}`,
+          `  title ${task.title}`,
           `  kind: ${task.kind}`,
-          `  status: ${task.status}`,
-          `  owner: ${task.owner}`,
-          `  cancellable: ${task.cancellable ? 'yes' : 'no'}`,
-          `  queuedAt: ${new Date(task.queuedAt).toISOString()}`,
-          `  startedAt: ${task.startedAt ? new Date(task.startedAt).toISOString() : 'n/a'}`,
-          `  endedAt: ${task.endedAt ? new Date(task.endedAt).toISOString() : 'n/a'}`,
-          `  parent: ${task.parentTaskId ?? 'none'}`,
-          `  children: ${task.childTaskIds.join(', ') || '(none)'}`,
-          `  correlationId: ${task.correlationId ?? 'n/a'}`,
-          `  summary: ${summarizeTaskResult(task)}`,
+          `  status ${task.status}`,
+          `  owner ${task.owner}`,
+          `  cancellable ${task.cancellable ? 'yes' : 'no'}`,
+          `  queued at ${new Date(task.queuedAt).toISOString()}`,
+          `  started at ${task.startedAt ? new Date(task.startedAt).toISOString() : 'n/a'}`,
+          `  ended at ${task.endedAt ? new Date(task.endedAt).toISOString() : 'n/a'}`,
+          `  parent ${task.parentTaskId ?? 'none'}`,
+          `  children ${task.childTaskIds.join(', ') || '(none)'}`,
+          `  correlation ID ${task.correlationId ?? 'n/a'}`,
+          `  summary ${summarizeTaskResult(task)}`,
         ].join('\n'));
         return;
       }
@@ -119,7 +119,7 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
         }
         const task = operatorClient.tasks.get(taskId);
         if (!task) {
-          ctx.print(`Unknown task: ${taskId}`);
+          ctx.print(`Unknown task ${taskId}`);
           return;
         }
         const payload = typeof task.result === 'string'
@@ -131,7 +131,7 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      ctx.print(`Unknown tasks subcommand: ${subcommand}`);
+      ctx.print(`Unknown tasks subcommand ${subcommand}`);
     },
   });
 }

package/src/input/commands/work-plan-runtime.ts

@@ -26,7 +26,12 @@ function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPla
 
 function formatList(store: WorkPlanStore): string {
   const items = store.listItems();
-  if (items.length === 0) return 'Work plan is empty. Add one with /workplan add <title>.';
+  if (items.length === 0) {
+    return [
+      'Work plan is empty',
+      '  next /workplan add <title>',
+    ].join('\n');
+  }
   return [
     `Work Plan (${items.length})`,
     ...items.map((item) => {
@@ -83,7 +88,7 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
       const subcommand = (commandArgs[0] ?? 'list').toLowerCase();
       try {
         if (subcommand === 'panel' || subcommand === 'open') {
-          ctx.print('Work plan panels are not part of the Agent workspace. Use /workplan list.');
+          ctx.print('Open Agent Workspace -> Work -> Work plan for the workspace view, or run /workplan list for compact command output.');
           return;
         }
         if (subcommand === 'list') {
@@ -106,7 +111,12 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
             ...(addArgs.notes ? { notes: addArgs.notes } : {}),
           };
           const item = store.addItem(addArgs.title, addOptions);
-          ctx.print(`Added work plan item ${item.id}. Use /workplan list to review.`);
+          ctx.print([
+            'Added work plan item',
+            `  id ${item.id}`,
+            `  title ${item.title}`,
+            '  next open Agent Workspace -> Work -> Work plan to review',
+          ].join('\n'));
           return;
         }
         if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
@@ -120,7 +130,11 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const item = store.removeItem(id);
-          ctx.print(`Removed work plan item ${item.id}: ${item.title}`);
+          ctx.print([
+            'Removed work plan item',
+            `  id ${item.id}`,
+            `  title ${item.title}`,
+          ].join('\n'));
           return;
         }
         if (subcommand === 'clear-done' || subcommand === 'clear-completed') {
@@ -129,7 +143,10 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const count = store.clearCompleted();
-          ctx.print(`Cleared ${count} completed/cancelled work plan item${count === 1 ? '' : 's'}.`);
+          ctx.print([
+            'Cleared completed/cancelled work plan items',
+            `  count ${count}`,
+          ].join('\n'));
           return;
         }
         if (subcommand === 'cycle' || subcommand === 'toggle') {
@@ -139,7 +156,11 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const item = store.cycleItemStatus(id);
-          ctx.print(`Updated ${item.id}: ${item.status}.`);
+          ctx.print([
+            'Updated work plan item',
+            `  id ${item.id}`,
+            `  status ${item.status}`,
+          ].join('\n'));
           return;
         }
         const status = STATUS_COMMANDS[subcommand];
@@ -150,14 +171,18 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const item = store.setItemStatus(id, status);
-          ctx.print(`Updated ${item.id}: ${item.status}.`);
+          ctx.print([
+            'Updated work plan item',
+            `  id ${item.id}`,
+            `  status ${item.status}`,
+          ].join('\n'));
           return;
         }
         if (WORK_PLAN_STATUSES.includes(subcommand as WorkPlanItemStatus)) {
           ctx.print(`Usage: /workplan ${subcommand} <id>`);
           return;
         }
-        ctx.print(`Unknown workplan subcommand: ${subcommand}`);
+        ctx.print(`Unknown workplan subcommand ${subcommand}`);
       } catch (error) {
         ctx.print(summarizeError(error));
       }

package/src/input/commands.ts

@@ -36,6 +36,9 @@ import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runt
 import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts';
 import { registerChannelsRuntimeCommands } from './commands/channels-runtime.ts';
 import { registerBriefRuntimeCommands } from './commands/brief-runtime.ts';
+import { registerSupportBundleRuntimeCommands } from './commands/support-bundle-runtime.ts';
+import { registerCompatRuntimeCommands } from './commands/compat-runtime.ts';
+import { registerOperatorActionRuntimeCommands } from './commands/operator-actions-runtime.ts';
 
 function registerAgentMemoryCommand(registry: CommandRegistry): void {
   registry.register({
@@ -58,6 +61,9 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
   registerBriefRuntimeCommands(registry);
+  registerSupportBundleRuntimeCommands(registry);
+  registerCompatRuntimeCommands(registry);
+  registerOperatorActionRuntimeCommands(registry);
   registerAgentRuntimeProfileRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);
@@ -66,7 +72,6 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerDelegationRuntimeCommands(registry);
   registerConfigCommand(registry);
   registerOperatorRuntimeCommands(registry);
-  registry.unregister('profiles');
   registerNotifyRuntimeCommands(registry);
   registerProductRuntimeCommands(registry);
   registerPlatformAccessRuntimeCommands(registry);
@@ -89,7 +94,6 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerPlanningRuntimeCommands(registry);
   registerScheduleRuntimeCommands(registry);
   registerSessionContentCommands(registry);
-  registry.unregister('session-memory');
   registerAgentMemoryCommand(registry);
 
   // ── /session ─────────────────────────────────────────────────────────────

package/src/input/feed-context-factory.ts

@@ -140,7 +140,6 @@ export interface FeedContextClosures {
   handleBlockCopy: () => void;
   handleBookmark: () => void;
   handleBlockSave: () => void;
-  handleDiffApply: () => boolean;
   handleUndo: () => void;
   handleRedo: () => void;
   handlePaste: () => void;
@@ -148,7 +147,8 @@ export interface FeedContextClosures {
   ensureInputCursorVisible: (contentWidth?: number) => void;
   registerPaste: (content: string) => string;
   executeBlockAction: (id: string) => void;
-  cyclePanelTab: (direction: 'next' | 'prev') => void;
+  cycleAgentWorkspaceCategory: (direction: 'next' | 'prev') => void;
+  dismissAgentWorkspace: () => boolean;
   onPanelInputConsumed: (activePanel: Panel | null, key: string) => void;
   getWrappedPromptInfo: (contentWidth: number) => WrappedPromptInfo;
   moveCursorVertical: (direction: -1 | 1) => boolean;