@pellux/goodvibes-agent 0.1.0

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

@@ -0,0 +1,434 @@
+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 { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireSecretsManager, requireServiceRegistry, requireShellPaths, requireSubscriptionManager } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+interface SubscriptionBundle {
+  readonly version: 1;
+  readonly exportedAt: number;
+  readonly subscriptions: readonly ProviderSubscription[];
+}
+
+function buildReviewText(ctx: CommandContext): string {
+  const subscriptions = requireSubscriptionManager(ctx).list();
+  const available = listAvailableSubscriptionProviders(requireServiceRegistry(ctx).getAll());
+  if (subscriptions.length === 0) {
+    return [
+      'Subscription Review',
+      '  No provider subscriptions stored yet.',
+      ...(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'}`
+    )),
+  ].join('\n');
+}
+
+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}`,
+    ...bundle.subscriptions.map((subscription) => `  ${subscription.provider}  ${subscription.authMode}`),
+  ].join('\n');
+}
+
+function extractAuthorizationCode(input: string): string | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  try {
+    const url = new URL(trimmed);
+    return url.searchParams.get('code');
+  } catch {
+    return null;
+  }
+}
+
+function resolveLoginConfig(config: OAuthProviderConfig, useLocalCallback: boolean): OAuthProviderConfig {
+  if (!useLocalCallback || !config.localCallback) {
+    return config.manualRedirectUri
+      ? { ...config, redirectUri: config.manualRedirectUri }
+      : config;
+  }
+  return 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';
+}
+
+export function registerSubscriptionRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    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]|finish <code-or-url>|logout <provider>|bundle export <path>|bundle inspect <path>]',
+    async handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      if (args.length === 0 && ctx.openSubscriptionPanel) {
+        ctx.openSubscriptionPanel();
+        return;
+      }
+      const sub = (args[0] ?? 'review').toLowerCase();
+      const manager = requireSubscriptionManager(ctx);
+      const services = requireServiceRegistry(ctx);
+
+      if (sub === 'review' || sub === 'list') {
+        ctx.print(buildReviewText(ctx));
+        return;
+      }
+
+      if (sub === 'providers') {
+        const available = listAvailableSubscriptionProviders(services.getAll());
+        if (available.length === 0) {
+          ctx.print('No subscription-capable providers are currently configured or built in.');
+          return;
+        }
+        ctx.print([
+          'Available Subscription Providers',
+          ...available.map((provider) => (
+            `  ${provider.provider}  source=${provider.source}  redirect=${provider.oauth.redirectUri}`
+          )),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'inspect') {
+        const provider = args[1];
+        if (!provider) {
+          ctx.print('Usage: /subscription inspect <provider>');
+          return;
+        }
+        const resolved = getSubscriptionProviderConfig(provider, services.get(provider));
+        if (!resolved && !manager.get(provider) && !manager.getPending(provider)) {
+          ctx.print(`No stored or available subscription provider named ${provider}.`);
+          return;
+        }
+        const inspection = await inspectProviderAuth(provider, {
+          serviceRegistry: services,
+          subscriptionManager: manager,
+          secretsManager: requireSecretsManager(ctx),
+        });
+        ctx.print([
+          `Subscription ${provider}`,
+          `  configured: ${inspection.configured ? 'yes' : 'no'}`,
+          `  freshness: ${inspection.freshness}`,
+          `  callbackMode: ${inspection.callbackMode}`,
+          ...(resolved ? [
+            `  source: ${resolved.source}`,
+            `  redirectUri: ${resolved.oauth.redirectUri}`,
+            `  authUrl: ${resolved.oauth.authUrl}`,
+            `  tokenUrl: ${resolved.oauth.tokenUrl}`,
+            ...(inspection.localCallback ? [`  localCallback: ${inspection.localCallback}`] : []),
+          ] : []),
+          ...(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'}`,
+            describePrecedence(manager.get(provider)!),
+          ] : [
+            `  state: ${inspection.freshness === 'pending' ? 'pending login' : 'available for login'}`,
+          ]),
+          ...inspection.issues.map((issue) => `  issue: ${issue}`),
+          ...inspection.nextActions.map((action) => `  next: ${action}`),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'login') {
+        const provider = args[1];
+        const mode = args[2]?.toLowerCase();
+        if (!provider || !mode) {
+          ctx.print('Usage: /subscription login <provider> start|finish <code>');
+          return;
+        }
+        const service = services.get(provider);
+        const resolved = getSubscriptionProviderConfig(provider, service);
+        if (!resolved) {
+          ctx.print([
+            `OAuth is not configured for ${provider}.`,
+            'Add an oauth block to .goodvibes/agent/services.json for that provider, for example:',
+            `  { "name": "${provider}", "authType": "oauth", "tokenKey": "${provider.toUpperCase()}_API_KEY", "providerId": "${provider}", "oauth": { "authUrl": "...", "tokenUrl": "...", "clientId": "...", "redirectUri": "http://127.0.0.1/callback", "scopes": ["..."] } }`,
+          ].join('\n'));
+          return;
+        }
+        if (mode === 'start') {
+          const flags = new Set(args.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({
+              provider,
+              state: started.state,
+              verifier: started.verifier,
+              redirectUri: started.redirectUri,
+              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>`,
+                  `  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>`,
+              '  authorizationUrl:',
+              `  ${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 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>`,
+                `  listener: ${summarizeError(error)}`,
+                '  authorizationUrl:',
+                `  ${started.authorizationUrl}`,
+              ].join('\n'));
+              return;
+            }
+          }
+
+          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>`,
+            '  authorizationUrl:',
+            `  ${started.authorizationUrl}`,
+          ].join('\n'));
+          return;
+        }
+        if (mode === 'finish') {
+          const codeInput = args[3];
+          if (!codeInput) {
+            ctx.print(`Usage: /subscription login ${provider} finish <code-or-url>`);
+            return;
+          }
+          const code = extractAuthorizationCode(codeInput) ?? codeInput;
+          if (provider === 'openai' && resolved.source === 'builtin') {
+            const pending = manager.getPending(provider);
+            if (!pending) {
+              ctx.print(`No pending OAuth login for ${provider}. Start with /subscription login ${provider} start.`);
+              return;
+            }
+            const token = await exchangeOpenAICodexCode(code, pending.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([
+              `Stored subscription session for ${provider}.`,
+              `  tokenType: ${record.tokenType}`,
+              `  expiresAt: ${record.expiresAt ? new Date(record.expiresAt).toISOString() : 'n/a'}`,
+              describePrecedence(record),
+            ].join('\n'));
+            return;
+          }
+          const activeConfig = resolveLoginConfig(resolved.oauth, false);
+          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'}`,
+            describePrecedence(record),
+          ].join('\n'));
+          return;
+        }
+        ctx.print('Usage: /subscription login <provider> start|finish <code-or-url>');
+        return;
+      }
+
+      if (sub === 'logout') {
+        const provider = args[1];
+        if (!provider) {
+          ctx.print('Usage: /subscription logout <provider>');
+          return;
+        }
+        const removed = manager.logout(provider);
+        ctx.print(removed
+          ? `Logged out of ${provider}. Ambient API key resolution will apply again if configured.`
+          : `No stored subscription session existed for ${provider}.`);
+        return;
+      }
+
+      if (sub === 'bundle') {
+        const mode = args[1]?.toLowerCase();
+        const pathArg = args[2];
+        if (!mode || !pathArg) {
+          ctx.print('Usage: /subscription bundle <export|inspect> <path>');
+          return;
+        }
+        const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+        if (mode === 'export') {
+          const bundle: SubscriptionBundle = {
+            version: 1,
+            exportedAt: Date.now(),
+            subscriptions: manager.list(),
+          };
+          mkdirSync(dirname(targetPath), { recursive: true });
+          writeFileSync(targetPath, `${JSON.stringify(bundle, null, 2)}\n`, 'utf-8');
+          ctx.print(`Subscription bundle exported to ${targetPath}`);
+          return;
+        }
+        if (mode === 'inspect') {
+          ctx.print(inspectBundle(targetPath));
+          return;
+        }
+        ctx.print('Usage: /subscription bundle <export|inspect> <path>');
+        return;
+      }
+
+      ctx.print('Usage: /subscription [review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual]|finish <code-or-url>|logout <provider>|bundle export <path>|bundle inspect <path>]');
+    },
+  });
+}

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

@@ -0,0 +1,230 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import type { RuntimeTask, TaskLifecycleState } from '@/runtime/index.ts';
+import { reviewWorktreeAttachments } from '@/runtime/index.ts';
+import { requireOperatorClient, requireOpsApi, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+function sortRuntimeTasks(tasks: RuntimeTask[]): RuntimeTask[] {
+  const statusOrder: TaskLifecycleState[] = ['running', 'queued', 'blocked', 'failed', 'completed', 'cancelled'];
+  const ranking = new Map(statusOrder.map((status, index) => [status, index] as const));
+  return [...tasks].sort((a, b) => {
+    const rankDelta = (ranking.get(a.status) ?? 99) - (ranking.get(b.status) ?? 99);
+    if (rankDelta !== 0) return rankDelta;
+    const aWhen = a.startedAt ?? a.queuedAt;
+    const bWhen = b.startedAt ?? b.queuedAt;
+    return bWhen - aWhen;
+  });
+}
+
+function summarizeTaskResult(task: RuntimeTask): string {
+  const payload = (
+    typeof task.result === 'string'
+      ? task.result
+      : task.error
+        ?? (task.result !== undefined ? JSON.stringify(task.result) : task.description)
+        ?? task.title
+  );
+  const normalized = String(payload).replace(/\s+/g, ' ').trim();
+  return normalized.length <= 140 ? normalized : `${normalized.slice(0, 137)}...`;
+}
+
+export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'tasks',
+    aliases: ['task'],
+    description: 'Inspect and control runtime tasks',
+    usage: '[list [status|kind] | show <taskId> | output <taskId> | create <kind> <owner> <title...> | update <taskId> <title|description|result> <value...> | complete <taskId> [result] | fail <taskId> <error...> | cancel <taskId> [note] | pause <taskId> [note] | resume <taskId> [note] | retry <taskId> [note]]',
+    handler(args, ctx) {
+      if (args.length === 0) {
+        if (ctx.showPanel) ctx.showPanel('tasks');
+        else {
+          const panelManager = requirePanelManager(ctx);
+          panelManager.open('tasks');
+          panelManager.show();
+          ctx.renderRequest();
+        }
+        return;
+      }
+
+      const operatorClient = requireOperatorClient(ctx);
+      const tasks = sortRuntimeTasks([...operatorClient.tasks.list(500)]);
+      const subcommand = args[0]?.toLowerCase() ?? 'list';
+
+      if (subcommand === 'list') {
+        const filter = args[1]?.toLowerCase();
+        const filtered = tasks.filter((task) => !filter || task.status === filter || task.kind === filter);
+        if (filtered.length === 0) {
+          ctx.print(filter ? `No tasks matched "${filter}".` : 'No tasks recorded yet.');
+          return;
+        }
+        ctx.print([
+          `Runtime 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;
+      }
+
+      if (subcommand === 'show') {
+        const taskId = args[1];
+        if (!taskId) {
+          ctx.print('Usage: /tasks show <taskId>');
+          return;
+        }
+        const task = operatorClient.tasks.get(taskId);
+        if (!task) {
+          ctx.print(`Unknown task: ${taskId}`);
+          return;
+        }
+        ctx.print([
+          `Task ${task.id}`,
+          `  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'}`,
+          ...(() => {
+            const shellPaths = requireShellPaths(ctx);
+            const worktrees = reviewWorktreeAttachments('task', task.id, {
+              workingDirectory: shellPaths.workingDirectory,
+            });
+            return worktrees.total > 0
+              ? [
+                  `  worktrees: ${worktrees.total} tracked (${worktrees.active} active / ${worktrees.paused} paused / ${worktrees.pendingCleanup} cleanup)`,
+                  `  worktree next: /worktree task ${task.id}`,
+                ]
+              : [];
+          })(),
+          `  summary: ${summarizeTaskResult(task)}`,
+        ].join('\n'));
+        return;
+      }
+
+      if (subcommand === 'output') {
+        const taskId = args[1];
+        if (!taskId) {
+          ctx.print('Usage: /tasks output <taskId>');
+          return;
+        }
+        const task = operatorClient.tasks.get(taskId);
+        if (!task) {
+          ctx.print(`Unknown task: ${taskId}`);
+          return;
+        }
+        const payload = typeof task.result === 'string'
+          ? task.result
+          : task.result !== undefined
+            ? JSON.stringify(task.result, null, 2)
+            : task.error ?? task.description ?? task.title;
+        ctx.print(String(payload));
+        return;
+      }
+
+      if (subcommand === 'create') {
+        const opsApi = requireOpsApi(ctx);
+        const kind = args[1];
+        const owner = args[2];
+        const title = args.slice(3).join(' ').trim();
+        if (!kind || !owner || !title) {
+          ctx.print('Usage: /tasks create <kind> <owner> <title...>');
+          return;
+        }
+        const validKinds = new Set(['exec', 'agent', 'acp', 'scheduler', 'daemon', 'mcp', 'plugin', 'integration']);
+        if (!validKinds.has(kind)) {
+          ctx.print(`Unknown task kind: ${kind}`);
+          return;
+        }
+        const task = opsApi.tasks.create({
+          kind: kind as import('@/runtime/index.ts').TaskKind,
+          owner,
+          title,
+          description: title,
+        });
+        ctx.print(`Created task ${task.id} (${task.kind}) for ${task.owner}.`);
+        return;
+      }
+
+      if (subcommand === 'update') {
+        const opsApi = requireOpsApi(ctx);
+        const taskId = args[1];
+        const field = args[2];
+        const value = args.slice(3).join(' ').trim();
+        if (!taskId || !field || !value) {
+          ctx.print('Usage: /tasks update <taskId> <title|description|result> <value...>');
+          return;
+        }
+        if (field !== 'title' && field !== 'description' && field !== 'result') {
+          ctx.print(`Unsupported task update field: ${field}`);
+          return;
+        }
+        opsApi.tasks.update(taskId, field === 'result' ? { result: value } : { [field]: value });
+        ctx.print(`Updated task ${taskId} field ${field}.`);
+        return;
+      }
+
+      if (subcommand === 'complete') {
+        const opsApi = requireOpsApi(ctx);
+        const taskId = args[1];
+        if (!taskId) {
+          ctx.print('Usage: /tasks complete <taskId> [result]');
+          return;
+        }
+        const result = args.slice(2).join(' ').trim() || undefined;
+        opsApi.tasks.complete(taskId, result);
+        ctx.print(`Completed task ${taskId}.`);
+        return;
+      }
+
+      if (subcommand === 'fail') {
+        const opsApi = requireOpsApi(ctx);
+        const taskId = args[1];
+        const errorText = args.slice(2).join(' ').trim();
+        if (!taskId || !errorText) {
+          ctx.print('Usage: /tasks fail <taskId> <error...>');
+          return;
+        }
+        opsApi.tasks.fail(taskId, { error: errorText });
+        ctx.print(`Failed task ${taskId}.`);
+        return;
+      }
+
+      const taskId = args[1];
+      const note = args.slice(2).join(' ').trim() || undefined;
+      if (!taskId) {
+        ctx.print(`Usage: /tasks ${subcommand} <taskId> [note]`);
+        return;
+      }
+      const opsApi = requireOpsApi(ctx);
+      try {
+        switch (subcommand) {
+          case 'cancel':
+            opsApi.tasks.cancel(taskId, note);
+            ctx.print(`Cancelled task ${taskId}.`);
+            return;
+          case 'pause':
+            opsApi.tasks.pause(taskId, note);
+            ctx.print(`Paused task ${taskId}.`);
+            return;
+          case 'resume':
+            opsApi.tasks.resume(taskId, note);
+            ctx.print(`Resumed task ${taskId}.`);
+            return;
+          case 'retry':
+            opsApi.tasks.retry(taskId, note);
+            ctx.print(`Re-queued task ${taskId}.`);
+            return;
+          default:
+            ctx.print(`Unknown tasks subcommand: ${subcommand}`);
+            return;
+        }
+      } catch (error) {
+        ctx.print(summarizeError(error));
+      }
+    },
+  });
+}