@pellux/goodvibes-agent 0.1.106 → 0.1.108

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

@@ -0,0 +1,126 @@
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { buildAgentWorkspaceRuntimeSnapshot } from '../agent-workspace-snapshot.ts';
+import { WORK_PLAN_STATUSES, type WorkPlanItemStatus } from '../../work-plans/work-plan-store.ts';
+
+type StatusCounts = Record<WorkPlanItemStatus, number>;
+
+function countReady<T extends { readonly status: string }>(items: readonly T[], status: string): number {
+  return items.filter((item) => item.status === status).length;
+}
+
+function workPlanCounts(ctx: CommandContext): { readonly total: number; readonly counts: StatusCounts } {
+  const counts = Object.fromEntries(WORK_PLAN_STATUSES.map((status) => [status, 0])) as StatusCounts;
+  try {
+    const items = ctx.workspace?.workPlanStore?.listItems?.() ?? [];
+    for (const item of items) {
+      counts[item.status] += 1;
+    }
+    return { total: items.length, counts };
+  } catch {
+    return { total: 0, counts };
+  }
+}
+
+function automationJobs(ctx: CommandContext): readonly AutomationJob[] {
+  try {
+    return ctx.ops?.automationManager?.listJobs?.() ?? [];
+  } catch {
+    return [];
+  }
+}
+
+function plural(count: number, singular: string, pluralWord = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : pluralWord}`;
+}
+
+function formatWorkPlanLine(total: number, counts: StatusCounts): string {
+  if (total === 0) return '  work plan: empty';
+  const active = counts.pending + counts.in_progress + counts.blocked;
+  return [
+    `  work plan: ${plural(total, 'item')}`,
+    `active ${active}`,
+    `pending ${counts.pending}`,
+    `in progress ${counts.in_progress}`,
+    `blocked ${counts.blocked}`,
+    `done ${counts.done}`,
+  ].join('; ');
+}
+
+function formatWarnings(warnings: readonly string[]): readonly string[] {
+  if (warnings.length === 0) return ['  warnings: none'];
+  return ['  warnings:', ...warnings.slice(0, 4).map((warning) => `    - ${warning}`)];
+}
+
+export function formatAgentOperatorBriefing(ctx: CommandContext): string {
+  const snapshot = buildAgentWorkspaceRuntimeSnapshot(ctx);
+  const workPlan = workPlanCounts(ctx);
+  const jobs = automationJobs(ctx);
+  const enabledJobs = jobs.filter((job) => job.enabled).length;
+  const setupReady = countReady(snapshot.setupChecklist, 'ready');
+  const setupRecommended = countReady(snapshot.setupChecklist, 'recommended');
+  const setupBlocked = countReady(snapshot.setupChecklist, 'blocked');
+  const readyChannels = snapshot.channels.filter((channel) => channel.ready).length;
+  const enabledChannels = snapshot.channels.filter((channel) => channel.enabled).length;
+
+  const nextActions = [
+    snapshot.provider === 'unknown' || snapshot.model === 'unknown'
+      ? 'Choose the assistant model with /model.'
+      : '',
+    snapshot.localMemoryCount === 0
+      ? 'Store durable non-secret facts with /memory add or the Agent workspace memory form.'
+      : snapshot.localMemoryReviewQueueCount > 0
+        ? `Review ${plural(snapshot.localMemoryReviewQueueCount, 'memory record')} with /memory queue.`
+        : '',
+    snapshot.localSkillCount === 0 && snapshot.localSkillBundleCount === 0
+      ? 'Create reusable procedures with /agent-skills create or import reviewed skill files.'
+      : snapshot.activeSkillCount === 0
+        ? 'Enable reviewed skills or bundles with /agent-skills enabled and /agent-skills bundle enabled.'
+        : '',
+    snapshot.localRoutineCount === 0
+      ? 'Create repeatable workflows with /routines create; promote schedules only with explicit confirmation.'
+      : snapshot.enabledRoutineCount === 0
+        ? 'Enable reviewed routines with /routines enable.'
+        : '',
+    'Use /knowledge status, /knowledge search, and explicit ingest forms for Agent Knowledge only.',
+    'Use /delegate only for explicit build, fix, implementation, or review handoff to GoodVibes TUI.',
+  ].filter((line): line is string => line.length > 0);
+
+  return [
+    'Agent Briefing',
+    `  chat route: ${snapshot.provider} / ${snapshot.modelDisplayName}`,
+    `  session: ${snapshot.sessionId}`,
+    `  profile: ${snapshot.activeRuntimeProfile}`,
+    `  policy: ${snapshot.executionPolicy}; WRFC ${snapshot.wrfcPolicy}`,
+    `  knowledge: ${snapshot.knowledgeRoute} (${snapshot.knowledgeIsolation}; no fallback)`,
+    '',
+    'Readiness',
+    `  setup: ${setupReady}/${snapshot.setupChecklist.length} ready; ${setupRecommended} recommended; ${setupBlocked} blocked`,
+    `  local memory: ${plural(snapshot.localMemoryCount, 'record')}; review queue ${snapshot.localMemoryReviewQueueCount}`,
+    `  personas: ${plural(snapshot.localPersonaCount, 'persona')}; active ${snapshot.activePersonaName}`,
+    `  skills: ${snapshot.enabledSkillCount}/${snapshot.localSkillCount} enabled; bundles ${snapshot.enabledSkillBundleCount}/${snapshot.localSkillBundleCount}; active ${snapshot.activeSkillCount}`,
+    `  routines: ${snapshot.enabledRoutineCount}/${snapshot.localRoutineCount} enabled`,
+    `  channels: ${readyChannels}/${snapshot.channels.length} ready; ${enabledChannels} enabled`,
+    `  voice/media: ${snapshot.voiceProviderCount} voice, ${snapshot.mediaProviderCount} media; browser surface ${snapshot.browserSurfaceEnabled ? 'enabled' : 'disabled'}`,
+    formatWorkPlanLine(workPlan.total, workPlan.counts),
+    `  schedules: ${enabledJobs}/${jobs.length} visible jobs enabled`,
+    '',
+    'Next Actions',
+    ...nextActions.map((line) => `  - ${line}`),
+    '',
+    ...formatWarnings(snapshot.warnings),
+  ].join('\n');
+}
+
+export function registerBriefRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'brief',
+    aliases: ['briefing'],
+    description: 'Show a concise Agent operator briefing and next actions',
+    usage: '',
+    argsHint: '',
+    handler(_args, ctx) {
+      ctx.print(formatAgentOperatorBriefing(ctx));
+    },
+  });
+}

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

@@ -0,0 +1,47 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { buildAgentWorkspaceChannels } from '../agent-workspace-channels.ts';
+
+export function registerChannelsRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'channels',
+    aliases: ['channel'],
+    description: 'Inspect Agent channel readiness without sending messages',
+    usage: '[list|readiness]',
+    argsHint: 'list|readiness',
+    handler(_args, ctx) {
+      const channels = buildAgentWorkspaceChannels(ctx);
+      const ready = channels.filter((channel) => channel.ready);
+      const enabled = channels.filter((channel) => channel.enabled);
+      const needsTarget = channels.filter((channel) => channel.setupState === 'needs-target');
+      const needsConfig = channels.filter((channel) => channel.setupState === 'needs-config');
+      const lines: string[] = [
+        'Channel Readiness',
+        `  ready: ${ready.length}/${channels.length}`,
+        `  enabled: ${enabled.length}/${channels.length}`,
+        `  needs target: ${needsTarget.length}`,
+        `  needs config: ${needsConfig.length}`,
+        '  policy: read-only inspection; sends require explicit user action and Agent policy',
+        '',
+        ...channels.map((channel) => {
+          const missing = channel.missingRequiredKeys.length > 0
+            ? ` missing=${channel.missingRequiredKeys.join('|')}`
+            : '';
+          const target = channel.configuredDefaultTargetKeys.length > 0
+            ? ` target=${channel.configuredDefaultTargetKeys.join('|')}`
+            : channel.defaultTargetKeys.length > 0
+              ? ` target=missing(${channel.defaultTargetKeys.join('|')})`
+              : ' target=not-required';
+          return [
+            `  ${channel.label}: ${channel.setupState}`,
+            `ready=${channel.ready ? 'yes' : 'no'}`,
+            `delivery=${channel.delivery}`,
+            `risk=${channel.risk}`,
+            target,
+            missing,
+          ].join(' ');
+        }),
+      ];
+      ctx.print(lines.join('\n'));
+    },
+  });
+}

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

@@ -77,13 +77,13 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
       if (sub === 'auth') {
         const auth = readModels.localAuth.getSnapshot();
         ctx.print([
-          'Health Review: Runtime Auth',
-          '  owner: external GoodVibes runtime host',
+          'Health Review: Connected-Service Auth',
+          '  owner: connected GoodVibes services',
           `  compatibility users visible: ${auth.userCount}`,
           `  compatibility sessions visible: ${auth.sessionCount}`,
           `  bootstrap file signal: ${auth.bootstrapCredentialPresent ? 'present' : 'cleared'}`,
-          '  Agent action: review provider/subscription auth only; do not mutate runtime auth users or bootstrap credentials.',
-          ...(auth.bootstrapCredentialPresent ? ['  issue: bootstrap cleanup belongs to the runtime-owning TUI or host tooling'] : []),
+          '  Agent action: review provider/subscription auth only; do not mutate connected-service auth users or bootstrap credentials.',
+          ...(auth.bootstrapCredentialPresent ? ['  issue: bootstrap cleanup belongs outside Agent'] : []),
         ].join('\n'));
         return;
       }
@@ -132,7 +132,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           `  degraded: ${snapshot.degradedConnections}`,
           ...(issues.length > 0 ? issues.map((issue) => `  issue: ${issue}`) : ['  no active remote recovery issues detected']),
           '  next: /delegate <build/fix/review task> for explicit TUI build work',
-          '  next: use the external runtime host for remote worker repair',
+          '  next: repair remote worker state outside Agent',
         ].join('\n'));
         return;
       }
@@ -217,7 +217,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           lines.push('  domain: settings');
           lines.push(...(
             settings.conflicts.length > 0
-              ? ['  /settings', '  /config <key>', '  runtime-owned managed setting repair stays external']
+              ? ['  /settings', '  /config <key>', '  service-owned managed setting repair stays external']
               : ['  no active settings repair actions suggested']
           ));
           lines.push('  verify: /health settings');
@@ -226,7 +226,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           lines.push('  /auth review');
           lines.push('  /provider');
           lines.push('  /subscription providers');
-          lines.push('  runtime auth users/bootstrap cleanup: use the runtime-owning GoodVibes TUI or host tooling');
+          lines.push('  connected-service auth users/bootstrap cleanup: manage outside Agent');
           lines.push('  verify: /health auth');
         } else if (domain === 'accounts') {
           lines.push('  domain: accounts');
@@ -238,12 +238,12 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         } else if (domain === 'services') {
           lines.push('  domain: services');
           lines.push('  /health services');
-          lines.push('  runtime service repair belongs to the external GoodVibes runtime host');
+          lines.push('  runtime service repair belongs outside Agent');
           lines.push('  verify: /health services');
         } else if (domain === 'remote') {
           lines.push('  domain: remote');
           lines.push('  /delegate <build/fix/review task> for explicit TUI build work');
-          lines.push('  remote runner setup and recovery belong to the external runtime host');
+          lines.push('  remote runner setup and recovery belong outside Agent');
           lines.push('  verify: /health remote');
         } else if (domain === 'mcp') {
           lines.push('  domain: mcp');
@@ -311,7 +311,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         `  account issues: ${accountSnapshot.issueCount}`,
         `  settings conflicts: ${settingsSnapshot.conflicts.length}`,
         `  managed locks: ${settingsSnapshot.managedLockCount}`,
-        `  runtime auth owner: external`,
+        `  connected-service auth owner: outside Agent`,
         `  remote workers: ${snapshot.remoteRunnerCount}`,
         ...formatSessionMaintenanceLines(maintenance, 'guided').map((line) => `  ${line}`),
         ...(snapshot.issues.length > 0 ? ['', ...snapshot.issues.map((issue) => `  [${issue.severity.toUpperCase()}] ${issue.area}: ${issue.message}`)] : []),

package/src/input/commands/knowledge.ts

@@ -1,8 +1,11 @@
 import type { 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';
 
 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];
@@ -63,6 +66,45 @@ function readPositiveIntFlag(args: string[], name: string, fallback: number): nu
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+function readFirstStringListFlag(args: string[], names: readonly string[]): string[] {
+  for (const name of names) {
+    const values = readStringListFlag(args, name);
+    if (values.length > 0) return values;
+  }
+  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;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
+  return Date.now() - parsed * 24 * 60 * 60 * 1000;
+}
+
+function parseConnectorInputFlag(args: string[]): unknown {
+  const value = readFlag(args, '--input');
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      return JSON.parse(trimmed) as unknown;
+    } catch {
+      return trimmed;
+    }
+  }
+  return trimmed;
+}
+
 function readJsonObjectFlag(args: string[], name: string): Record<string, unknown> | null | undefined {
   const value = readFlag(args, name);
   if (!value) return undefined;
@@ -159,7 +201,7 @@ export const knowledgeCommand: SlashCommand = {
   aliases: ['know', 'kb'],
   description: 'Agent Knowledge/Wiki: isolated Agent-owned sources, graph, review queue, and compact prompt packets.',
   usage: '<subcommand> [args]',
-  argsHint: 'status|ask|ingest-url --yes|import-bookmarks --yes|list|search|get|queue|review-issue --yes',
+  argsHint: 'status|ask|ingest-url --yes|ingest-file --yes|import-bookmarks --yes|list|search|get|queue|review-issue --yes',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const knowledge = requireAgentKnowledgeApi(context);
     if (!knowledge) {
@@ -243,6 +285,31 @@ export const knowledgeCommand: SlashCommand = {
         break;
       }
 
+      case 'ingest-file':
+      case 'ingest-artifact': {
+        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');
+          return;
+        }
+        if (!confirmation.yes) {
+          requireYesFlag(context, `ingest file into Agent Knowledge ${path}`, '/knowledge ingest-file <path> [--title <title>] [--tags <a,b>] [--folder <path>] --yes');
+          return;
+        }
+        const result = await knowledge.ingest.artifact({
+          path,
+          title: readFlag(rest, '--title'),
+          tags: readStringListFlag(rest, '--tags'),
+          folderPath: readFlag(rest, '--folder'),
+          sessionId: context.session.runtime.sessionId,
+          connectorId: readFlag(rest, '--connector') ?? 'goodvibes-agent-file',
+        });
+        context.print(`[knowledge] Ingested ${result.source.id} ${result.source.canonicalUri ?? result.source.sourceUri ?? path}`);
+        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) {
@@ -279,6 +346,61 @@ export const knowledgeCommand: SlashCommand = {
         break;
       }
 
+      case 'import-browser-history':
+      case 'sync-browser-history': {
+        if (!confirmation.yes) {
+          requireYesFlag(context, 'import browser history into Agent Knowledge', '/knowledge import-browser-history [--browsers chrome,firefox] [--sources history,bookmark] [--limit <n>] [--since-days <n>] --yes');
+          return;
+        }
+        const result = await knowledge.ingest.browserHistory({
+          browsers: toBrowserKinds(readFirstStringListFlag(rest, ['--browsers', '--browser'])),
+          sourceKinds: toBrowserSourceKinds(readFirstStringListFlag(rest, ['--sources', '--source-kinds', '--source-kind'])),
+          homeOverride: readFlag(rest, '--home'),
+          limit: readPositiveIntFlag(rest, '--limit', 250),
+          sinceMs: readSinceMsFlag(rest),
+          connectorId: 'goodvibes-agent-browser-history',
+          sessionId: context.session.runtime.sessionId,
+        });
+        context.print(`[knowledge] Imported browser knowledge: ${result.imported} ok, ${result.failed} failed`);
+        if (result.profiles.length > 0) context.print(`  profiles: ${result.profiles.length}`);
+        if (result.errors.length > 0) {
+          for (const error of result.errors.slice(0, 10)) context.print(`  error: ${error}`);
+        }
+        break;
+      }
+
+      case 'ingest-connector': {
+        const [connectorId] = positionalArgs(rest, ['--input', '--path', '--content']);
+        if (!connectorId) {
+          context.print('[knowledge] Usage: /knowledge ingest-connector <connectorId> [--input <json-or-text>|--path <path>|--content <text>] --yes');
+          return;
+        }
+        const input = parseConnectorInputFlag(rest);
+        const path = readFlag(rest, '--path');
+        const content = readFlag(rest, '--content');
+        if (input === undefined && !path && !content) {
+          context.print('[knowledge] Usage: /knowledge ingest-connector <connectorId> [--input <json-or-text>|--path <path>|--content <text>] --yes');
+          return;
+        }
+        if (!confirmation.yes) {
+          requireYesFlag(context, `ingest connector input into Agent Knowledge for ${connectorId}`, '/knowledge ingest-connector <connectorId> [--input <json-or-text>|--path <path>|--content <text>] --yes');
+          return;
+        }
+        const result = await knowledge.ingest.connectorInput({
+          connectorId,
+          input,
+          path,
+          content,
+          sessionId: context.session.runtime.sessionId,
+          allowPrivateHosts: rest.includes('--allow-private-hosts'),
+        });
+        context.print(`[knowledge] Imported connector input: ${result.imported} ok, ${result.failed} failed`);
+        if (result.errors.length > 0) {
+          for (const error of result.errors.slice(0, 10)) context.print(`  error: ${error}`);
+        }
+        break;
+      }
+
       case 'list': {
         const limit = Math.max(1, Number.parseInt(readFlag(rest, '--limit') ?? '10', 10) || 10);
         const kind = (readFlag(rest, '--kind') ?? 'sources').toLowerCase();
@@ -464,6 +586,55 @@ export const knowledgeCommand: SlashCommand = {
         break;
       }
 
+      case 'connectors': {
+        const [first, second] = positionalArgs(rest);
+        if (first === 'doctor') {
+          if (!second) {
+            context.print('[knowledge] Usage: /knowledge connectors doctor <connectorId>');
+            return;
+          }
+          const report = await knowledge.connectors.doctor(second);
+          if (!report) {
+            context.print(`[knowledge] Connector doctor report unavailable: ${second}`);
+            return;
+          }
+          context.print([
+            `[knowledge] Connector doctor ${report.connectorId}`,
+            `  ready: ${report.ready ? 'yes' : 'no'}`,
+            `  summary: ${report.summary}`,
+            ...(report.checks.length > 0 ? ['  checks:', ...report.checks.slice(0, 10).map((check) => `    - ${check.id} [${check.status}] ${check.label} - ${check.detail}`)] : []),
+            ...(report.hints.length > 0 ? ['  hints:', ...report.hints.slice(0, 8).map((hint) => `    - ${hint}`)] : []),
+          ].join('\n'));
+          return;
+        }
+        if (first) {
+          const connector = knowledge.connectors.get(first);
+          if (!connector) {
+            context.print(`[knowledge] Unknown connector: ${first}`);
+            return;
+          }
+          context.print([
+            `[knowledge] Connector ${connector.id}`,
+            `  name: ${connector.displayName ?? connector.id}`,
+            `  sourceType: ${connector.sourceType}`,
+            `  description: ${connector.description}`,
+            `  capabilities: ${connector.capabilities?.join(', ') || 'none'}`,
+          ].join('\n'));
+          return;
+        }
+        const connectors = knowledge.connectors.list();
+        if (connectors.length === 0) {
+          context.print('[knowledge] No connectors.');
+          return;
+        }
+        context.print(`[knowledge] Connectors (${connectors.length}):`);
+        for (const connector of connectors) {
+          context.print(`  ${connector.id} [${connector.sourceType}] ${connector.displayName ?? connector.id}`);
+          context.print(`    ${connector.description}`);
+        }
+        break;
+      }
+
       case 'reports': {
         const [limitArg] = positionalArgs(rest);
         const limit = Math.max(1, Number.parseInt(limitArg ?? '10', 10) || 10);
@@ -564,14 +735,18 @@ export const knowledgeCommand: SlashCommand = {
           '  status',
           '  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-connector <connectorId> [--input <json-or-text>|--path <path>|--content <text>] --yes',
           '  import-bookmarks <path> --yes',
           '  import-urls <path> --yes',
+          '  import-browser-history [--browsers chrome,firefox] [--sources history,bookmark] [--limit <n>] [--since-days <n>] --yes',
           '  list [--kind <sources|nodes|issues>] [--limit <n>]',
           '  search <query> [--limit <n>]',
           '  get <id>',
           '  queue [limit]',
           '  review-issue <issueId> <accept|reject|resolve|reopen|edit|forget> [--reviewer <name>] [--value <json-object>] --yes',
           '  candidates [limit]',
+          '  connectors [connectorId|doctor <connectorId>]',
           '  reports [limit]',
           '  schedules',
           '  lint',

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

@@ -62,7 +62,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         const parsed = stripYesFlag(args);
         const subcommand = parsed.rest[0]?.toLowerCase() ?? '';
         if ((subcommand === 'override' || subcommand === 'clear') && !parsed.yes) {
-          requireYesFlag(ctx, `${subcommand} planner runtime state`, `/plan ${subcommand}${subcommand === 'override' ? ' <strategy>' : ''} --yes`);
+          requireYesFlag(ctx, `${subcommand} planner state`, `/plan ${subcommand}${subcommand === 'override' ? ' <strategy>' : ''} --yes`);
           return;
         }
         const result = ctx.ops.planRuntime

package/src/input/commands/platform-access-runtime.ts

@@ -55,9 +55,9 @@ export function registerPlatformAccessRuntimeCommands(registry: CommandRegistry)
       }
       if (target === 'service' || target === 'runtime' || target === 'listener' || target === 'daemon') {
         ctx.print([
-          'Runtime service login is external to GoodVibes Agent.',
-          'Agent does not create, exchange, store, rotate, revoke, or clear runtime/listener service sessions.',
-          'Use the runtime-owning GoodVibes TUI or host tooling for runtime auth administration.',
+          'Connected-service login is outside GoodVibes Agent.',
+          'Agent does not create, exchange, store, rotate, revoke, or clear connected-service sessions.',
+          'Use the owning GoodVibes host for connected-service auth administration.',
           'Agent login supports provider subscriptions only: /login provider <name> start|finish <code> --yes.',
         ].join('\n'));
         return;
@@ -100,18 +100,18 @@ export function registerPlatformAccessRuntimeCommands(registry: CommandRegistry)
       const sub = commandArgs[0] ?? 'review';
       if (sub === 'local') {
         ctx.print([
-          'Local runtime auth management is external to GoodVibes Agent.',
-          'Agent connects to an already-running GoodVibes runtime and does not create, delete, rotate, revoke, or clear runtime auth users, sessions, or bootstrap credentials.',
-          'Use the runtime-owning GoodVibes TUI or host tooling for runtime auth administration.',
+          'Connected-service auth management is outside GoodVibes Agent.',
+          'Agent connects to GoodVibes services owned outside this package and does not create, delete, rotate, revoke, or clear connected-service auth users, sessions, or bootstrap credentials.',
+          'Use the owning GoodVibes host for connected-service auth administration.',
           'Agent auth commands available here: /auth review, /auth show <provider>, /auth repair <provider>, /auth bundle export <path> --yes, /auth bundle inspect <path>.',
         ].join('\n'));
         return;
       }
       if (sub === 'login') {
         ctx.print([
-          'Runtime service login is external to GoodVibes Agent.',
-          'Agent does not create, exchange, store, rotate, revoke, or clear runtime/listener service sessions.',
-          'Use the runtime-owning GoodVibes TUI or host tooling for runtime auth administration.',
+          'Connected-service login is outside GoodVibes Agent.',
+          'Agent does not create, exchange, store, rotate, revoke, or clear connected-service sessions.',
+          'Use the owning GoodVibes host for connected-service auth administration.',
         ].join('\n'));
         return;
       }
@@ -129,7 +129,7 @@ export function registerPlatformAccessRuntimeCommands(registry: CommandRegistry)
         const builtinProviders = listBuiltinSubscriptionProviders().map((entry) => entry.provider);
         ctx.print([
           'Auth Review',
-          '  runtime auth: managed outside goodvibes-agent',
+          '  connected-service auth: managed outside goodvibes-agent',
           `  stored secrets: ${snapshot.secretKeyCount}`,
           `  built-in providers: ${builtinProviders.length}${builtinProviders.length > 0 ? ` (${builtinProviders.join(', ')})` : ''}`,
           `  active subscriptions: ${snapshot.activeSubscriptions}${snapshot.activeSubscriptions > 0 ? ` (${snapshot.providers.filter((provider) => provider.activeSubscription).map((provider) => provider.provider).join(', ')})` : ''}`,

package/src/input/commands/policy-dispatch.ts

@@ -15,7 +15,7 @@ import { requireShellPaths } from './runtime-services.ts';
 function getPolicyState(ctx?: CommandContext): PolicyRuntimeState {
   const policyRuntimeState = ctx?.extensions.policyRuntimeState;
   if (!policyRuntimeState) {
-    throw new Error('Policy runtime state is not available in this runtime.');
+    throw new Error('Policy state is not available in this Agent session.');
   }
   return policyRuntimeState;
 }

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

@@ -4,6 +4,17 @@ import {
 } from '@pellux/goodvibes-sdk/platform/automation';
 import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation';
 import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation';
+import {
+  buildReminderSchedulePreview,
+  createReminderSchedule,
+  parseReminderScheduleArgs,
+  resolveReminderDaemonConnection,
+} from '../../agent/reminder-schedule.ts';
+import {
+  formatReminderScheduleFailure,
+  formatReminderSchedulePreview,
+  formatReminderScheduleSuccess,
+} from '../../agent/reminder-schedule-format.ts';
 import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
@@ -56,7 +67,7 @@ function printReadOnlyScheduleBoundary(print: (text: string) => void, requestedA
     `  requested: ${requestedAction}`,
     '  policy: no local Agent automation jobs, scheduled spawns, or immediate automation runs',
     '  use: /schedule list',
-    '  schedule route: use /schedule promote-routine <routine> --cron <expr> --yes to create an external schedule explicitly',
+    '  schedule route: use /schedule promote-routine <routine> --cron <expr> --yes to create a connected schedule explicitly',
   ].join('\n'));
 }
 
@@ -86,16 +97,41 @@ async function promoteRoutineSchedule(args: readonly string[], ctx: CommandConte
   ctx.print(result.ok ? `${formatRoutineScheduleSuccess(result)}\n  receipt: ${receipt.id}` : `${formatRoutineScheduleFailure(result)}\n  receipt: ${receipt.id}`);
 }
 
+async function createReminder(args: readonly string[], ctx: CommandContext): Promise<void> {
+  const parsed = parseReminderScheduleArgs(args);
+  if (parsed.errors.length > 0) {
+    ctx.print([
+      'Usage: /schedule remind (--cron <expr>|--every <interval>|--at <iso-time>) (--message <text>|<text...>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--delivery-channel <channel[:route[:label]]>|--delivery-route <route[:label]>|--delivery-webhook <url>|--delivery-link <url>] [--disabled] --yes',
+      ...parsed.errors.map((error) => `  ${error}`),
+    ].join('\n'));
+    return;
+  }
+  const preview = buildReminderSchedulePreview(parsed);
+  if (!parsed.yes) {
+    ctx.print(formatReminderSchedulePreview(preview));
+    return;
+  }
+  const shellPaths = requireShellPaths(ctx);
+  const connection = resolveReminderDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const result = await createReminderSchedule(connection, preview);
+  ctx.print(result.ok ? formatReminderScheduleSuccess(result) : formatReminderScheduleFailure(result));
+}
+
 export function registerScheduleRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'schedule',
     aliases: ['sched'],
-    description: 'Inspect schedules and explicitly promote local Agent routines to external schedules',
-    usage: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-channel slack] --yes',
-    argsHint: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-channel slack] --yes',
+    description: 'Inspect schedules, create confirmed reminders, and explicitly promote local Agent routines to connected schedules',
+    usage: 'list | remind --at <iso> --message <text> --yes | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-channel slack] --yes',
+    argsHint: 'list | remind --at <iso> --message <text> --yes | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-channel slack] --yes',
     async handler(args, ctx) {
       const sub = args[0];
 
+      if (sub === 'remind' || sub === 'reminder') {
+        await createReminder(args.slice(1), ctx);
+        return;
+      }
+
       if (sub === 'promote-routine' || sub === 'promote' || sub === 'create-routine-schedule') {
         await promoteRoutineSchedule(args.slice(1), ctx);
         return;
@@ -136,7 +172,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         if (jobs.length === 0) {
           ctx.print(
             'No automation jobs.\n'
-            + 'Local add/run/enable/disable/remove are blocked. Use /schedule promote-routine <routine> --cron <expr> --yes for an explicit external schedule.'
+            + 'Local add/run/enable/disable/remove are blocked. Use /schedule remind --at <time> --message <text> --yes for reminders or /schedule promote-routine <routine> --cron <expr> --yes for explicit connected schedules.'
           );
           return;
         }
@@ -164,6 +200,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         + '  /schedule receipts\n'
         + '  /schedule reconcile\n'
         + '  /schedule receipt <receipt-id>\n'
+        + '  /schedule remind (--cron <expr>|--every <interval>|--at <iso-time>) (--message <text>|<text...>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes\n'
         + '  /schedule promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes\n'
         + '  Local schedule mutations and runs remain blocked.'
       );

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

@@ -24,7 +24,7 @@ export function registerSecurityRuntimeCommands(registry: CommandRegistry): void
       const securitySnapshot = requireReadModels(ctx).security.getSnapshot();
       const policySnapshot = ctx.extensions.policyRuntimeState?.getSnapshot();
       if (!policySnapshot) {
-        ctx.print('Policy runtime state is not available in this runtime.');
+        ctx.print('Policy state is not available in this Agent session.');
         return;
       }
       const attackPaths = buildMcpAttackPathReview({