@pellux/goodvibes-agent 1.1.6 → 1.2.0

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

@@ -1,15 +1,20 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { CommandContext } from '../command-registry.ts';
-import type { AgentWorkspaceChannelStatus } from '../agent-workspace-channels.ts';
-import { buildAgentWorkspaceChannels } from '../agent-workspace-channels.ts';
+import type { AgentWorkspaceChannelSetupGuide, AgentWorkspaceChannelStatus } from '../agent-workspace-channels.ts';
+import { buildAgentWorkspaceChannelTriage, formatAgentWorkspaceChannelTriage } from '../agent-workspace-channel-triage.ts';
+import { buildAgentWorkspaceChannelSetupGuide, buildAgentWorkspaceChannels } from '../agent-workspace-channels.ts';
+import { fetchConnectedHostReadOnlyRoute, formatConnectedHostRouteFailure } from '../connected-host-routes.ts';
 import {
   buildAgentChannelDeliveryPreview,
   deliverAgentChannelMessage,
   formatAgentChannelDeliveryPreview,
   formatAgentChannelDeliveryResult,
 } from '../../agent/channel-delivery.ts';
+import {
+  formatAgentChannelDeliveryReceiptLine,
+  readAgentChannelDeliveryReceipts,
+  recordAgentChannelDeliveryReceipt,
+} from '../../agent/channel-delivery-receipts.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 type ChannelFilter = 'all' | 'ready' | 'attention';
@@ -26,35 +31,6 @@ interface ChannelSendArgs {
   readonly errors: readonly string[];
 }
 
-interface ChannelConnectedHostConnection {
-  readonly baseUrl: string;
-  readonly token: string | null;
-  readonly tokenPath: string;
-}
-
-interface ChannelRouteSuccess {
-  readonly ok: true;
-  readonly route: string;
-  readonly body: unknown;
-}
-
-interface ChannelRouteFailure {
-  readonly ok: false;
-  readonly route: string;
-  readonly kind: 'auth_required' | 'connected_host_unavailable' | 'connected_host_route_unavailable' | 'connected_host_error';
-  readonly baseUrl: string;
-  readonly message: string;
-}
-
-type ChannelRouteResult = ChannelRouteSuccess | ChannelRouteFailure;
-
-const CHANNEL_FAILURE_LABELS: Record<ChannelRouteFailure['kind'], string> = {
-  auth_required: 'auth required',
-  connected_host_unavailable: 'connected host unavailable',
-  connected_host_route_unavailable: 'connected host route unavailable',
-  connected_host_error: 'connected host error',
-};
-
 function isRecord(value: unknown): value is JsonRecord {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -69,6 +45,13 @@ function readBoolean(record: JsonRecord, key: string, fallback = false): boolean
   return typeof value === 'boolean' ? value : fallback;
 }
 
+function readLimitValue(value: string | undefined, fallback: number): number {
+  if (!value) return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(100, Math.trunc(parsed)));
+}
+
 function readRecordArray(record: JsonRecord, key: string): readonly JsonRecord[] {
   const value = record[key];
   return Array.isArray(value) ? value.filter(isRecord) : [];
@@ -126,83 +109,28 @@ function parseChannelSendArgs(args: readonly string[]): ChannelSendArgs {
   };
 }
 
-function resolveChannelConnectedHostConnection(context: CommandContext): ChannelConnectedHostConnection {
-  const hostValue = context.platform?.configManager?.get('controlPlane.host');
-  const portValue = context.platform?.configManager?.get('controlPlane.port');
-  const host = typeof hostValue === 'string' && hostValue.trim().length > 0 ? hostValue.trim() : '127.0.0.1';
-  const port = typeof portValue === 'number' && Number.isFinite(portValue) ? portValue : 3421;
-  const homeDirectory = context.workspace?.shellPaths?.homeDirectory ?? process.env.HOME ?? '';
-  const tokenPath = join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
-  if (!existsSync(tokenPath)) return { baseUrl: `http://${host}:${port}`, token: null, tokenPath };
-  try {
-    const parsed = JSON.parse(readFileSync(tokenPath, 'utf-8')) as unknown;
-    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
-    return { baseUrl: `http://${host}:${port}`, token, tokenPath };
-  } catch {
-    return { baseUrl: `http://${host}:${port}`, token: null, tokenPath };
-  }
-}
-
-async function fetchChannelRoute(context: CommandContext, route: string): Promise<ChannelRouteResult> {
-  const connection = resolveChannelConnectedHostConnection(context);
-  if (!connection.token) {
-    return {
-      ok: false,
-      route,
-      kind: 'auth_required',
-      baseUrl: connection.baseUrl,
-      message: `No connected-host operator token found at ${connection.tokenPath}`,
-    };
-  }
-
-  try {
-    const response = await fetch(`${connection.baseUrl}${route}`, {
-      headers: { authorization: `Bearer ${connection.token}` },
-    });
-    const text = await response.text();
-    let body: unknown = text;
-    if (text.trim().length > 0) {
-      try {
-        body = JSON.parse(text) as unknown;
-      } catch {
-        body = text;
-      }
-    }
-    if (!response.ok) {
-      const detail = isRecord(body) && typeof body.error === 'string' ? body.error : text;
-      return {
-        ok: false,
-        route,
-        kind: response.status === 401 || response.status === 403
-          ? 'auth_required'
-          : response.status === 404
-            ? 'connected_host_route_unavailable'
-            : 'connected_host_error',
-        baseUrl: connection.baseUrl,
-        message: `HTTP ${response.status}${detail ? `: ${detail}` : ''}`,
-      };
-    }
-    return { ok: true, route, body };
-  } catch (error) {
-    return {
-      ok: false,
-      route,
-      kind: 'connected_host_unavailable',
-      baseUrl: connection.baseUrl,
-      message: error instanceof Error ? error.message : String(error),
-    };
+function formatChannelDeliveryReceipts(context: CommandContext, limitArg?: string): string {
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) {
+    return [
+      'Channel Delivery Receipts',
+      '  status unavailable',
+      '  reason Agent shell paths are unavailable in this runtime.',
+    ].join('\n');
   }
-}
-
-function formatChannelRouteFailure(title: string, failure: ChannelRouteFailure): string {
+  const limit = readLimitValue(limitArg, 10);
+  const snapshot = readAgentChannelDeliveryReceipts(shellPaths);
+  const receipts = snapshot.receipts.slice(0, limit);
   return [
-    `${title}: unavailable`,
-    `  status: ${CHANNEL_FAILURE_LABELS[failure.kind]}`,
-    `  kind: ${failure.kind}`,
-    `  connected host: ${failure.baseUrl}`,
-    `  route: ${failure.route}`,
-    `  error: ${failure.message}`,
-    '  policy: read-only; no channel send/action route was called',
+    'Channel Delivery Receipts',
+    `  path ${snapshot.path}`,
+    `  total ${snapshot.receipts.length}`,
+    `  returned ${receipts.length}`,
+    `  status ${snapshot.parseError ? 'attention' : snapshot.exists ? 'ready' : 'empty'}`,
+    ...(snapshot.parseError ? [`  parse error ${snapshot.parseError}`] : []),
+    '  policy confirmed sends only; message bodies and secret-bearing target values are bounded or redacted',
+    ...receipts.map((receipt) => `  ${formatAgentChannelDeliveryReceiptLine(receipt)}`),
+    ...(receipts.length === 0 ? ['  no channel deliveries recorded yet'] : []),
   ].join('\n');
 }
 
@@ -285,6 +213,36 @@ function printChannelDetail(
   ].join('\n'));
 }
 
+function formatGuideStepStatus(status: string): string {
+  if (status === 'complete') return '[x]';
+  if (status === 'current') return '[>]';
+  return '[ ]';
+}
+
+function formatChannelSetupGuide(guide: AgentWorkspaceChannelSetupGuide): string {
+  const lines = [
+    'Channel Setup Guide',
+    `  state: ${guide.status}`,
+    `  progress: ${guide.progressLabel}`,
+    `  current channel: ${guide.currentChannelLabel ?? 'choose a channel'}${guide.currentChannelId ? ` (${guide.currentChannelId})` : ''}`,
+    `  summary: ${guide.summary}`,
+    `  ready: ${guide.readyChannels}/${guide.totalChannels}; enabled: ${guide.enabledChannels}; attention: ${guide.attentionChannels}; targets: ${guide.configuredTargets}`,
+    `  policy: ${guide.policy}`,
+    '',
+    '  Steps',
+  ];
+  for (const step of guide.steps) {
+    lines.push(`  ${formatGuideStepStatus(step.status)} ${step.label}: ${step.userRoute}`);
+    if (step.status === 'current') lines.push(`      next: ${step.detail}`);
+  }
+  lines.push('', '  Channel order');
+  for (const channel of guide.channels.slice(0, 10)) {
+    lines.push(`  - ${channel.label}: ${channel.setupState}; ${channel.summary}; guide ${channel.guideRoute}`);
+  }
+  if (guide.channels.length > 10) lines.push(`  ${guide.channels.length - 10} more channel(s) omitted.`);
+  return lines.join('\n');
+}
+
 function formatChannelAccounts(body: unknown): string {
   const root = isRecord(body) ? body : {};
   const accounts = readRecordArray(root, 'accounts');
@@ -407,9 +365,9 @@ async function printReadOnlyChannelRoute(
   route: string,
   format: (body: unknown) => string,
 ): Promise<void> {
-  const result = await fetchChannelRoute(context, route);
+  const result = await fetchConnectedHostReadOnlyRoute(context, route);
   if (!result.ok) {
-    context.print(formatChannelRouteFailure(title, result));
+    context.print(formatConnectedHostRouteFailure(title, result, 'read-only; no channel send/action route was called'));
     return;
   }
   context.print(format(result.body));
@@ -420,8 +378,8 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
     name: 'channels',
     aliases: ['channel'],
     description: 'Inspect Agent channel readiness or send an explicitly confirmed delivery message',
-    usage: '[list|readiness|ready|attention|show <id>|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]',
-    argsHint: 'list|readiness|ready|attention|show|send|accounts|policies|status|doctor|setup',
+    usage: '[list|readiness|ready|attention|triage [limit]|guide [id]|show <id>|deliveries [limit]|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]',
+    argsHint: 'list|readiness|ready|attention|triage|guide|show|deliveries|send|accounts|policies|status|doctor|setup',
     async handler(args, ctx) {
       const channels = buildAgentWorkspaceChannels(ctx);
       const subcommand = (args[0] ?? 'readiness').trim().toLowerCase();
@@ -441,6 +399,17 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (subcommand === 'guide' || subcommand === 'setup-guide') {
+        const channelId = args[1]?.trim();
+        ctx.print(formatChannelSetupGuide(buildAgentWorkspaceChannelSetupGuide(channels, channelId ? { channelId } : {})));
+        return;
+      }
+
+      if (subcommand === 'triage' || subcommand === 'inbox') {
+        ctx.print(formatAgentWorkspaceChannelTriage(await buildAgentWorkspaceChannelTriage(ctx, { limit: args[1] })));
+        return;
+      }
+
       if (subcommand === 'show') {
         const channelId = args[1]?.trim().toLowerCase();
         if (!channelId) {
@@ -456,6 +425,11 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (subcommand === 'deliveries' || subcommand === 'receipts') {
+        ctx.print(formatChannelDeliveryReceipts(ctx, args[1]));
+        return;
+      }
+
       if (subcommand === 'send') {
         const router = ctx.platform.channelDeliveryRouter;
         if (!router) {
@@ -480,7 +454,21 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         try {
-          ctx.print(formatAgentChannelDeliveryResult(await deliverAgentChannelMessage(router, parsed)));
+          const result = await deliverAgentChannelMessage(router, parsed);
+          const lines = [formatAgentChannelDeliveryResult(result)];
+          if (ctx.workspace?.shellPaths) {
+            try {
+              const receipt = recordAgentChannelDeliveryReceipt(ctx.workspace.shellPaths, {
+                source: 'command',
+                deliveryInput: parsed,
+                result,
+              });
+              lines.push(`  receipt ${receipt.id}`);
+            } catch (receiptError) {
+              lines.push(`  receipt unavailable ${receiptError instanceof Error ? receiptError.message : String(receiptError)}`);
+            }
+          }
+          ctx.print(lines.join('\n'));
         } catch (error) {
           ctx.print(`[channels] Send failed ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -517,7 +505,7 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
-      ctx.print('Usage: /channels [list|readiness|ready|attention|show <id>|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]');
+      ctx.print('Usage: /channels [list|readiness|ready|attention|triage [limit]|guide [id]|show <id>|deliveries [limit]|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]');
     },
   });
 }

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

@@ -10,31 +10,83 @@ function hasAnyFlag(args: readonly string[], flags: readonly string[]): boolean
   return flags.some((flag) => hasFlag(args, flag));
 }
 
-function delegationTaskValues(args: readonly string[]): string[] {
-  const values: string[] = [];
+interface DelegationCommandInput {
+  readonly task: string;
+  readonly reviewRequested: boolean;
+  readonly reason: string;
+  readonly successCriteria: string;
+  readonly workspaceHint: string;
+  readonly priority: string;
+}
+
+function parseDelegationArgs(args: readonly string[], defaultReview: boolean): DelegationCommandInput {
+  const taskValues: string[] = [];
+  let reason = '';
+  let successCriteria = '';
+  let workspaceHint = '';
+  let priority = '';
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index]!;
     if (token === '--review' || token === '--wrfc') continue;
+    if (token === '--reason') {
+      reason = args[index + 1]?.trim() ?? '';
+      index += 1;
+      continue;
+    }
+    if (token === '--success' || token === '--success-criteria') {
+      successCriteria = args[index + 1]?.trim() ?? '';
+      index += 1;
+      continue;
+    }
+    if (token === '--workspace' || token === '--worktree') {
+      workspaceHint = args[index + 1]?.trim() ?? '';
+      index += 1;
+      continue;
+    }
+    if (token === '--priority') {
+      priority = args[index + 1]?.trim() ?? '';
+      index += 1;
+      continue;
+    }
     if (!token.startsWith('--')) {
-      values.push(token);
+      taskValues.push(token);
       continue;
     }
   }
-  return values;
+  return {
+    task: taskValues.join(' ').trim(),
+    reviewRequested: defaultReview || hasAnyFlag(args, ['--review', '--wrfc']),
+    reason,
+    successCriteria,
+    workspaceHint,
+    priority,
+  };
 }
 
-function buildDelegationBody(task: string, reviewRequested: boolean): string {
+function buildDelegationBody(input: DelegationCommandInput): string {
   return [
     'GoodVibes Agent explicit build delegation.',
     '',
     'Original user ask',
-    task,
+    input.task,
+    '',
+    'Delegation reason',
+    input.reason || '(not supplied)',
+    '',
+    'Success criteria or expected evidence',
+    input.successCriteria || '(not supplied)',
+    '',
+    'Workspace or worktree hint',
+    input.workspaceHint || '(not supplied)',
+    '',
+    'Priority or deadline',
+    input.priority || '(not supplied)',
     '',
     'Agent policy',
     '- GoodVibes Agent is not the coding TUI.',
     '- Preserve the full original ask.',
     '- GoodVibes TUI owns file edits, git/worktree flows, execution isolation UX, and any delegated review owner chain.',
-    reviewRequested
+    input.reviewRequested
       ? '- Delegated review was explicitly requested by the Agent user for this build/fix/review handoff.'
       : '- Delegated review was not explicitly requested; do not add review solely because this came from Agent.',
   ].join('\n');
@@ -42,10 +94,11 @@ function buildDelegationBody(task: string, reviewRequested: boolean): string {
 
 export function registerDelegationRuntimeCommands(registry: CommandRegistry): void {
   const makeHandler = (defaultReview: boolean) => async (args: string[], ctx: CommandContext): Promise<void> => {
-    const reviewRequested = defaultReview || hasAnyFlag(args, ['--review', '--wrfc']);
-    const task = delegationTaskValues(args).join(' ').trim();
-    if (!task) {
-      ctx.print(defaultReview ? 'Usage: /delegate --review <build/fix/review task>' : 'Usage: /delegate [--review] <build/fix/review task>');
+    const input = parseDelegationArgs(args, defaultReview);
+    if (!input.task) {
+      ctx.print(defaultReview
+        ? 'Usage: /delegate --review [--reason <why>] [--success <evidence>] [--workspace <hint>] [--priority <priority>] <build/fix/review task>'
+        : 'Usage: /delegate [--review] [--reason <why>] [--success <evidence>] [--workspace <hint>] [--priority <priority>] <build/fix/review task>');
       return;
     }
     const operator = ctx.clients?.operator;
@@ -65,31 +118,39 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
         lastSeenAt: Date.now(),
       } satisfies SharedSessionParticipant;
       const session = await operator.sessions.ensureSession({
-        title: `Agent delegation: ${task.slice(0, 72)}`,
+        title: `Agent delegation: ${input.task.slice(0, 72)}`,
         participant,
         metadata: {
           originSurface: 'goodvibes-agent',
           sourceSessionId: ctx.session.runtime.sessionId,
-          task,
-          reviewRequested,
-          wrfcRequested: reviewRequested,
+          task: input.task,
+          reviewRequested: input.reviewRequested,
+          wrfcRequested: input.reviewRequested,
+          delegationReason: input.reason,
+          successCriteria: input.successCriteria,
+          workspaceHint: input.workspaceHint,
+          priority: input.priority,
         },
       });
       await operator.sessions.submitMessage({
         sessionId: session.id,
-        body: buildDelegationBody(task, reviewRequested),
+        body: buildDelegationBody(input),
         surfaceKind: participant.surfaceKind,
         surfaceId: participant.surfaceId,
         externalId: participant.externalId,
         displayName: participant.displayName,
-        title: `Agent delegation: ${task.slice(0, 72)}`,
+        title: `Agent delegation: ${input.task.slice(0, 72)}`,
         metadata: {
           originSurface: 'goodvibes-agent',
           sourceSessionId: ctx.session.runtime.sessionId,
           kind: 'task',
-          task,
-          reviewRequested,
-          wrfcRequested: reviewRequested,
+          task: input.task,
+          reviewRequested: input.reviewRequested,
+          wrfcRequested: input.reviewRequested,
+          delegationReason: input.reason,
+          successCriteria: input.successCriteria,
+          workspaceHint: input.workspaceHint,
+          priority: input.priority,
         },
         routing: {
           executionIntent: {
@@ -103,8 +164,10 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
       ctx.print([
         'Delegation submitted to GoodVibes TUI/shared-session routes.',
         `  session ${session.id}`,
-        `  mode ${reviewRequested ? 'delegated review requested' : 'direct build delegation'}`,
-        `  task ${task}`,
+        `  mode ${input.reviewRequested ? 'delegated review requested' : 'direct build delegation'}`,
+        `  task ${input.task}`,
+        ...(input.reason ? [`  reason ${input.reason}`] : []),
+        ...(input.successCriteria ? [`  success ${input.successCriteria}`] : []),
         '  next check GoodVibes TUI shared-session/task status for the result.',
       ].join('\n'));
     } catch (error) {
@@ -120,8 +183,8 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
     name: 'delegate',
     aliases: ['build'],
     description: 'Explicitly delegate build/fix/review work to GoodVibes TUI through shared-session routes',
-    usage: '[--review] <task>',
-    argsHint: '[--review] <task>',
+    usage: '[--review] [--reason <why>] [--success <evidence>] [--workspace <hint>] [--priority <priority>] <task>',
+    argsHint: '[--review] [--reason <why>] [--success <evidence>] [--workspace <hint>] [--priority <priority>] <task>',
     handler: makeHandler(false),
   });
 }

package/src/input/commands/knowledge-browser-flags.ts

@@ -0,0 +1,12 @@
+import type { BrowserKnowledgeKind, BrowserKnowledgeSourceKind } from '@pellux/goodvibes-sdk/platform/knowledge';
+
+const BROWSER_KINDS = ['chrome', 'chromium', 'brave', 'edge', 'vivaldi', 'arc', 'opera', 'firefox', 'zen', 'librewolf', 'waterfox', 'floorp', 'safari', 'orion', 'epiphany'] as const satisfies readonly BrowserKnowledgeKind[];
+const BROWSER_SOURCE_KINDS = ['history', 'bookmark'] as const satisfies readonly BrowserKnowledgeSourceKind[];
+
+export function toBrowserKinds(values: readonly string[]): readonly BrowserKnowledgeKind[] {
+  return values.filter((value): value is BrowserKnowledgeKind => BROWSER_KINDS.includes(value as BrowserKnowledgeKind));
+}
+
+export function toBrowserSourceKinds(values: readonly string[]): readonly BrowserKnowledgeSourceKind[] {
+  return values.filter((value): value is BrowserKnowledgeSourceKind => BROWSER_SOURCE_KINDS.includes(value as BrowserKnowledgeSourceKind));
+}

package/src/input/commands/knowledge.ts

@@ -1,11 +1,9 @@
 import type { KnowledgeMapResult, KnowledgeService } from '@pellux/goodvibes-sdk/platform/knowledge';
-import type { BrowserKnowledgeKind, BrowserKnowledgeSourceKind } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { CommandContext, SlashCommand } from '../command-registry.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import { toBrowserKinds, toBrowserSourceKinds } from './knowledge-browser-flags.ts';
 
 const KNOWLEDGE_REVIEW_ACTIONS = ['accept', 'reject', 'resolve', 'reopen', 'edit', 'forget'] as const;
-const BROWSER_KINDS = ['chrome', 'chromium', 'brave', 'edge', 'vivaldi', 'arc', 'opera', 'firefox', 'zen', 'librewolf', 'waterfox', 'floorp', 'safari', 'orion', 'epiphany'] as const satisfies readonly BrowserKnowledgeKind[];
-const BROWSER_SOURCE_KINDS = ['history', 'bookmark'] as const satisfies readonly BrowserKnowledgeSourceKind[];
 
 type KnowledgeReviewAction = typeof KNOWLEDGE_REVIEW_ACTIONS[number];
 type KnowledgeAskInput = Parameters<KnowledgeService['ask']>[0];
@@ -78,14 +76,6 @@ function readFirstStringListFlag(args: string[], names: readonly string[]): stri
   return [];
 }
 
-function toBrowserKinds(values: readonly string[]): readonly BrowserKnowledgeKind[] {
-  return values.filter((value): value is BrowserKnowledgeKind => BROWSER_KINDS.includes(value as BrowserKnowledgeKind));
-}
-
-function toBrowserSourceKinds(values: readonly string[]): readonly BrowserKnowledgeSourceKind[] {
-  return values.filter((value): value is BrowserKnowledgeSourceKind => BROWSER_SOURCE_KINDS.includes(value as BrowserKnowledgeSourceKind));
-}
-
 function readSinceMsFlag(args: string[]): number | undefined {
   const raw = readFlag(args, '--since-days');
   if (!raw) return undefined;
@@ -211,7 +201,7 @@ export const knowledgeCommand: SlashCommand = {
   aliases: ['know', 'kb'],
   description: 'Agent Knowledge: isolated Agent-owned status, ask/search, source/node/issue lists, item lookup, map, connectors, ingest, and review queue.',
   usage: '<subcommand> [args]',
-  argsHint: 'status|ask|search|list|get|map|connectors|connector|connector-doctor|ingest-url --yes|ingest-file --yes|import-urls --yes|import-bookmarks --yes|import-browser-history --yes|ingest-connector --yes|review-issue --yes|reindex --yes',
+  argsHint: 'status|ask|search|list|get|map|connectors|connector|connector-doctor|ingest-url --yes|ingest-file --yes|ingest-artifact --yes|import-urls --yes|import-bookmarks --yes|import-browser-history --yes|ingest-connector --yes|review-issue --yes|reindex --yes',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     if (args.length === 0 && context.openAgentWorkspace) {
       context.openAgentWorkspace('knowledge');
@@ -295,8 +285,7 @@ export const knowledgeCommand: SlashCommand = {
         break;
       }
 
-      case 'ingest-file':
-      case 'ingest-artifact': {
+      case 'ingest-file': {
         const [path] = positionalArgs(rest, ['--title', '--tags', '--folder', '--connector']);
         if (!path) {
           context.print('[knowledge] Usage: /knowledge ingest-file <path> [--title <title>] [--tags <a,b>] [--folder <path>] --yes');
@@ -320,6 +309,30 @@ export const knowledgeCommand: SlashCommand = {
         break;
       }
 
+      case 'ingest-artifact': {
+        const [artifactId] = positionalArgs(rest, ['--title', '--tags', '--folder', '--connector']);
+        if (!artifactId) {
+          context.print('[knowledge] Usage: /knowledge ingest-artifact <artifactId> [--title <title>] [--tags <a,b>] [--folder <path>] --yes');
+          return;
+        }
+        if (!confirmation.yes) {
+          requireYesFlag(context, `ingest artifact into Agent Knowledge ${artifactId}`, '/knowledge ingest-artifact <artifactId> [--title <title>] [--tags <a,b>] [--folder <path>] --yes');
+          return;
+        }
+        const result = await knowledge.ingest.artifact({
+          artifactId,
+          title: readFlag(rest, '--title'),
+          tags: readStringListFlag(rest, '--tags'),
+          folderPath: readFlag(rest, '--folder'),
+          sessionId: context.session.runtime.sessionId,
+          connectorId: readFlag(rest, '--connector') ?? 'goodvibes-agent-artifact-browser',
+        });
+        context.print(`[knowledge] Ingested ${result.source.id} ${result.source.canonicalUri ?? result.source.sourceUri ?? artifactId}`);
+        if (result.source.summary) context.print(`  ${result.source.summary}`);
+        if (result.artifactId) context.print(`  artifact: ${result.artifactId}`);
+        break;
+      }
+
       case 'import-bookmarks': {
         const [path] = positionalArgs(rest);
         if (!path) {
@@ -757,6 +770,7 @@ export const knowledgeCommand: SlashCommand = {
           '  ask <query> [--limit <n>] [--mode <concise|standard|detailed>]',
           '  ingest-url <url> [--title <title>] [--tags <a,b>] [--folder <path>] --yes',
           '  ingest-file <path> [--title <title>] [--tags <a,b>] [--folder <path>] --yes',
+          '  ingest-artifact <artifactId> [--title <title>] [--tags <a,b>] [--folder <path>] --yes',
           '  ingest-connector <connectorId> [--input <json-or-text>|--path <path>|--content <text>] --yes',
           '  import-bookmarks <path> --yes',
           '  import-urls <path> --yes',

package/src/input/commands/operator-actions-runtime.ts

@@ -98,6 +98,9 @@ function automationActionFromParts(scope: string, verb: string): {
   if ((scope === 'run' || scope === 'runs') && verb === 'cancel') return { action: 'automation.runs.cancel', targetField: 'runId' };
   if ((scope === 'run' || scope === 'runs') && verb === 'retry') return { action: 'automation.runs.retry', targetField: 'runId' };
   if ((scope === 'schedule' || scope === 'schedules') && verb === 'run') return { action: 'schedules.run', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && verb === 'enable') return { action: 'schedules.enable', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && verb === 'disable') return { action: 'schedules.disable', targetField: 'scheduleId' };
+  if ((scope === 'schedule' || scope === 'schedules') && (verb === 'delete' || verb === 'remove')) return { action: 'schedules.delete', targetField: 'scheduleId' };
   return null;
 }
 
@@ -120,14 +123,14 @@ export function registerOperatorActionRuntimeCommands(registry: CommandRegistry)
     name: 'automation',
     aliases: ['auto'],
     description: 'Run confirmed connected-host automation actions from the Agent TUI',
-    usage: 'job <run|pause|resume> <job-id> --yes | run <cancel|retry> <run-id> --yes | schedule run <schedule-id> --yes',
-    argsHint: 'job run <id> --yes | run cancel <id> --yes | schedule run <id> --yes',
+    usage: 'job <run|pause|resume> <job-id> --yes | run <cancel|retry> <run-id> --yes | schedule <run|enable|disable|delete> <schedule-id> --yes',
+    argsHint: 'job run <id> --yes | run cancel <id> --yes | schedule disable <id> --yes',
     async handler(args, ctx) {
       const scope = (args[0] ?? '').toLowerCase();
       const verb = (args[1] ?? '').toLowerCase();
       const targetId = args[2] ?? '';
       const mapping = automationActionFromParts(scope, verb);
-      const usage = '/automation job <run|pause|resume> <job-id> --yes | /automation run <cancel|retry> <run-id> --yes | /automation schedule run <schedule-id> --yes';
+      const usage = '/automation job <run|pause|resume> <job-id> --yes | /automation run <cancel|retry> <run-id> --yes | /automation schedule <run|enable|disable|delete> <schedule-id> --yes';
       if (!mapping || !targetId) {
         ctx.print(`Usage: ${usage}`);
         return;