@pellux/goodvibes-agent 1.1.7 → 1.3.0

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

@@ -34,6 +34,18 @@ import {
   reconcileRoutineScheduleReceipts,
   RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-receipts.ts';
+import {
+  buildScheduleEditPreview,
+  editConnectedSchedule,
+  enrichScheduleEditPreviewFromConnectedHost,
+  parseScheduleEditArgs,
+  resolveScheduleEditConnectedHostConnection,
+} from '../../agent/schedule-edit.ts';
+import {
+  formatScheduleEditFailure,
+  formatScheduleEditPreview,
+  formatScheduleEditSuccess,
+} from '../../agent/schedule-edit-format.ts';
 import type { CommandContext } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 import { executeConfirmedOperatorAction } from './operator-actions-runtime.ts';
@@ -119,13 +131,42 @@ async function createReminder(args: readonly string[], ctx: CommandContext): Pro
   ctx.print(result.ok ? formatReminderScheduleSuccess(result) : formatReminderScheduleFailure(result));
 }
 
+async function editSchedule(args: readonly string[], ctx: CommandContext): Promise<void> {
+  const parsed = parseScheduleEditArgs(args, {
+    defaultExplicitUserRequest: `/schedule edit ${args[0] ?? ''}`.trim(),
+  });
+  if (parsed.errors.length > 0) {
+    ctx.print([
+      'Usage: /schedule edit <schedule-id> [--cron <expr>|--every <interval>|--at <iso-time>] [--timezone <tz>] [--stagger-ms <ms>] [--name <text>] [--prompt <text>|--task <text> --success-criteria <text>] --yes',
+      ...parsed.errors.map((error) => `  ${error}`),
+    ].join('\n'));
+    return;
+  }
+  let preview = buildScheduleEditPreview(parsed);
+  if (!parsed.yes) {
+    try {
+      const shellPaths = requireShellPaths(ctx);
+      const connection = resolveScheduleEditConnectedHostConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+      preview = await enrichScheduleEditPreviewFromConnectedHost(connection, preview);
+    } catch {
+      // A basic preview is still safer than blocking confirmation on local path services.
+    }
+    ctx.print(formatScheduleEditPreview(preview));
+    return;
+  }
+  const shellPaths = requireShellPaths(ctx);
+  const connection = resolveScheduleEditConnectedHostConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const result = await editConnectedSchedule(connection, preview);
+  ctx.print(result.ok ? formatScheduleEditSuccess(result) : formatScheduleEditFailure(result));
+}
+
 export function registerScheduleRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'schedule',
     aliases: ['sched'],
     description: 'Inspect schedules, create confirmed reminders, and explicitly promote Agent-local 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',
+    usage: 'list | edit <id> --cron <expr> --yes | remind --at <iso> --message <text> --yes | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
+    argsHint: 'list | edit <id> --cron <expr> --yes | remind --at <iso> --message <text> --yes | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
     async handler(args, ctx) {
       const sub = args[0];
 
@@ -163,6 +204,28 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (sub === 'edit' || sub === 'update' || sub === 'patch') {
+        await editSchedule(args.slice(1), ctx);
+        return;
+      }
+
+      if (sub === 'run' || sub === 'enable' || sub === 'disable' || sub === 'delete' || sub === 'remove') {
+        const scheduleId = args[1] ?? '';
+        if (!scheduleId) {
+          ctx.print(`Usage: /schedule ${sub} <schedule-id> --yes`);
+          return;
+        }
+        const action = sub === 'run'
+          ? 'schedules.run'
+          : sub === 'enable'
+            ? 'schedules.enable'
+            : sub === 'disable'
+              ? 'schedules.disable'
+              : 'schedules.delete';
+        await executeConfirmedOperatorAction(ctx, action, 'scheduleId', scheduleId, args.slice(2), `/schedule ${sub} <schedule-id> --yes`);
+        return;
+      }
+
       const manager = ctx.ops.automationManager;
       if (!manager) {
         ctx.print('Automation manager is not available in this runtime.');
@@ -191,17 +254,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
-      if (sub === 'run') {
-        const scheduleId = args[1] ?? '';
-        if (!scheduleId) {
-          ctx.print('Usage: /schedule run <schedule-id> --yes');
-          return;
-        }
-        await executeConfirmedOperatorAction(ctx, 'schedules.run', 'scheduleId', scheduleId, args.slice(2), '/schedule run <schedule-id> --yes');
-        return;
-      }
-
-      if (sub === 'add' || sub === 'remove' || sub === 'enable' || sub === 'disable') {
+      if (sub === 'add') {
         printReadOnlyScheduleBoundary(ctx.print, `/schedule ${args.join(' ')}`.trim());
         return;
       }
@@ -213,9 +266,13 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         + '  /schedule reconcile\n'
         + '  /schedule receipt <receipt-id>\n'
         + '  /schedule run <schedule-id> --yes\n'
+        + '  /schedule enable <schedule-id> --yes\n'
+        + '  /schedule disable <schedule-id> --yes\n'
+        + '  /schedule delete <schedule-id> --yes\n'
+        + '  /schedule edit <schedule-id> [--cron <expr>|--every <interval>|--at <iso-time>] [--name <text>] [--prompt <text>|--task <text> --success-criteria <text>] --yes\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 remain blocked; schedule run is a confirmed connected-host action.'
+        + '  Local schedule creation remains blocked; schedule lifecycle/edit actions are confirmed connected-host actions.'
       );
     },
   });

package/src/input/commands/session-content.ts

@@ -197,7 +197,7 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     argsHint: '',
     handler(args, ctx) {
       if (args.length > 0) {
-        ctx.print('Usage: /undo\n  Removes the last conversation turn. File edit undo belongs to the delegated GoodVibes TUI session.');
+        ctx.print('Usage: /undo\n  Removes the last conversation turn. Use execution action:"recovery" for local file edit undo.');
         return;
       }
       const success = ctx.session.conversationManager.undo();
@@ -217,7 +217,7 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     argsHint: '',
     handler(args, ctx) {
       if (args.length > 0) {
-        ctx.print('Usage: /redo\n  Restores the last undone conversation turn. File edit redo belongs to the delegated GoodVibes TUI session.');
+        ctx.print('Usage: /redo\n  Restores the last undone conversation turn. Use execution action:"recovery" for local file edit redo.');
         return;
       }
       const success = ctx.session.conversationManager.redo();

package/src/input/commands/shell-core.ts

@@ -26,6 +26,8 @@ function commandCategory(commandName: string): string {
     'knowledge',
     'memory',
     'notes',
+    'vibe',
+    'vibes',
     'personas',
     'skills',
     'routines',

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

@@ -0,0 +1,140 @@
+import { AgentPersonaRegistry } from '../../agent/persona-registry.ts';
+import {
+  discoverVibeFiles,
+  formatVibeStatus,
+  initVibeFile,
+  loadVibeImportSource,
+  resolveVibePathReference,
+} from '../../agent/vibe-file.ts';
+import {
+  formatVibeConfirmationRouteLines,
+  vibeImportPersonaConfirmationRoutes,
+  vibeInitConfirmationRoutes,
+} from '../../agent/vibe-confirmation-routes.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { parseAgentLocalLibraryArgs } from './agent-local-library-args.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+const VIBE_VALUE_FLAGS = ['name', 'description'] as const;
+
+function printError(ctx: CommandContext, error: unknown): void {
+  ctx.print([
+    'Error',
+    `  message ${error instanceof Error ? error.message : String(error)}`,
+  ].join('\n'));
+}
+
+function usage(): string {
+  return [
+    'Usage: /vibe [status|init|show|import-persona]',
+    '  /vibe',
+    '  /vibe init [--global] [--force] --yes',
+    '  /vibe show [project|global|path]',
+    '  /vibe import-persona [project|global|path] [--name <name>] [--description <summary>] [--review] [--use] --yes',
+  ].join('\n');
+}
+
+export function registerVibeRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'vibe',
+    aliases: ['vibes'],
+    description: 'Inspect, create, and import VIBE.md personality files',
+    usage: '[status|init|show|import-persona]',
+    async handler(args, ctx) {
+      const sub = (args[0] ?? 'status').toLowerCase();
+      const shellPaths = requireShellPaths(ctx);
+      try {
+        if (sub === 'status' || sub === 'list' || sub === 'open') {
+          ctx.print(formatVibeStatus(discoverVibeFiles(shellPaths)));
+          return;
+        }
+
+        if (sub === 'init') {
+          const parsed = parseAgentLocalLibraryArgs(args.slice(1), { valueFlags: VIBE_VALUE_FLAGS });
+          const scope = parsed.flags.has('global') ? 'global' : 'project';
+          const previewPath = scope === 'global'
+            ? resolveVibePathReference(shellPaths, 'global')
+            : resolveVibePathReference(shellPaths, 'project');
+          if (!parsed.yes) {
+            ctx.print([
+              'VIBE.md init preview',
+              `  scope ${scope}`,
+              `  path ${previewPath}`,
+              ...formatVibeConfirmationRouteLines(vibeInitConfirmationRoutes(scope, parsed.flags.has('force'))),
+            ].join('\n'));
+            return;
+          }
+          const result = initVibeFile(shellPaths, { scope, force: parsed.flags.has('force') });
+          ctx.print(result.created
+            ? `Created ${scope} VIBE.md\n  path ${result.path}`
+            : `VIBE.md already exists\n  path ${result.path}\n  next rerun with --force --yes to replace it`);
+          return;
+        }
+
+        if (sub === 'show') {
+          const reference = args.slice(1).join(' ').trim() || 'project';
+          const source = loadVibeImportSource(shellPaths, reference);
+          ctx.print([
+            `${source.scope === 'global' ? 'Global' : 'Project'} VIBE.md`,
+            `  path ${source.path}`,
+            `  name ${source.name}`,
+            `  description ${source.description}`,
+            '',
+            source.body,
+          ].join('\n'));
+          return;
+        }
+
+        if (sub === 'import-persona' || sub === 'import') {
+          const parsed = parseAgentLocalLibraryArgs(args.slice(1), { valueFlags: VIBE_VALUE_FLAGS });
+          const reference = parsed.rest.join(' ').trim() || 'project';
+          const source = loadVibeImportSource(shellPaths, reference);
+          const name = parsed.flags.get('name')?.trim() || source.name;
+          const description = parsed.flags.get('description')?.trim() || source.description;
+          if (!parsed.yes) {
+            ctx.print([
+              'VIBE.md persona import preview',
+              `  source ${source.scope}`,
+              `  path ${source.path}`,
+              `  name ${name}`,
+              `  description ${description}`,
+              `  body characters ${source.body.length}`,
+              ...formatVibeConfirmationRouteLines(vibeImportPersonaConfirmationRoutes({
+                reference,
+                name,
+                description,
+                review: parsed.flags.has('review'),
+                use: parsed.flags.has('use'),
+              })),
+            ].join('\n'));
+            return;
+          }
+          const personaRegistry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+          const persona = personaRegistry.create({
+            name,
+            description,
+            body: source.body,
+            tags: ['vibe', source.scope],
+            triggers: ['vibe'],
+            source: 'imported',
+            provenance: `Imported VIBE.md (${source.scope}): ${source.path}`,
+          });
+          if (parsed.flags.has('review')) personaRegistry.markReviewed(persona.id);
+          if (parsed.flags.has('use')) personaRegistry.setActive(persona.id);
+          ctx.print([
+            `Imported VIBE.md persona ${persona.id}: ${persona.name}`,
+            `  source ${source.scope}`,
+            `  path ${source.path}`,
+            `  reviewed ${parsed.flags.has('review') ? 'yes' : 'no'}`,
+            `  active ${parsed.flags.has('use') ? 'yes' : 'no'}`,
+          ].join('\n'));
+          return;
+        }
+
+        ctx.print(usage());
+      } catch (error) {
+        printError(ctx, error);
+      }
+    },
+  });
+}

package/src/input/commands.ts

@@ -32,6 +32,7 @@ import { registerAgentWorkspaceRuntimeCommands } from './commands/agent-workspac
 import { registerAgentRuntimeProfileRuntimeCommands } from './commands/agent-runtime-profile-runtime.ts';
 import { registerDelegationRuntimeCommands } from './commands/delegation-runtime.ts';
 import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
+import { registerVibeRuntimeCommands } from './commands/vibe-runtime.ts';
 import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runtime.ts';
 import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts';
 import { registerChannelsRuntimeCommands } from './commands/channels-runtime.ts';
@@ -65,6 +66,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerCompatRuntimeCommands(registry);
   registerOperatorActionRuntimeCommands(registry);
   registerAgentRuntimeProfileRuntimeCommands(registry);
+  registerVibeRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);
   registerRoutinesRuntimeCommands(registry);

package/src/input/connected-host-routes.ts

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { CommandContext } from './command-registry.ts';
+
+export interface ConnectedHostConnection {
+  readonly baseUrl: string;
+  readonly token: string | null;
+  readonly tokenPath: string;
+}
+
+export interface ConnectedHostRouteSuccess {
+  readonly ok: true;
+  readonly route: string;
+  readonly body: unknown;
+}
+
+export interface ConnectedHostRouteFailure {
+  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;
+}
+
+export type ConnectedHostRouteResult = ConnectedHostRouteSuccess | ConnectedHostRouteFailure;
+
+export const CONNECTED_HOST_FAILURE_LABELS: Record<ConnectedHostRouteFailure['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 Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function resolveConnectedHostConnection(context: CommandContext): ConnectedHostConnection {
+  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 };
+  }
+}
+
+export async function fetchConnectedHostReadOnlyRoute(
+  context: CommandContext,
+  route: string,
+): Promise<ConnectedHostRouteResult> {
+  const connection = resolveConnectedHostConnection(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),
+    };
+  }
+}
+
+export function formatConnectedHostRouteFailure(
+  title: string,
+  failure: ConnectedHostRouteFailure,
+  policy = 'read-only; no mutation route was called',
+): string {
+  return [
+    `${title}: unavailable`,
+    `  status: ${CONNECTED_HOST_FAILURE_LABELS[failure.kind]}`,
+    `  kind: ${failure.kind}`,
+    `  connected host: ${failure.baseUrl}`,
+    `  route: ${failure.route}`,
+    `  error: ${failure.message}`,
+    `  policy: ${policy}`,
+  ].join('\n');
+}

package/src/input/settings-modal-types.ts

@@ -32,6 +32,18 @@ export type SettingsCategory =
   | 'tts'
   | 'surfaces'
   | 'automation'
+  | 'service'
+  | 'controlPlane'
+  | 'httpListener'
+  | 'web'
+  | 'watchers'
+  | 'network'
+  | 'orchestration'
+  | 'runtime'
+  | 'sandbox'
+  | 'batch'
+  | 'cloudflare'
+  | 'wrfc'
   | 'telemetry'
   | 'cache'
   | 'mcp'
@@ -48,6 +60,8 @@ export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
   { label: 'Models and Providers', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts'] },
   { label: 'Agent-local state', categories: ['storage', 'cache', 'telemetry'] },
   { label: 'Channels and Tools', categories: ['surfaces', 'mcp', 'automation'] },
+  { label: 'Daemon Runtime', categories: ['service', 'controlPlane', 'httpListener', 'web', 'watchers', 'network'] },
+  { label: 'Advanced Runtime', categories: ['orchestration', 'runtime', 'sandbox', 'batch', 'cloudflare', 'wrfc'] },
   { label: 'Advanced', categories: ['flags', 'release'] },
 ];
 

package/src/input/setup-wizard-live-receipts.ts

@@ -0,0 +1,76 @@
+import type { CommandContext } from './command-registry.ts';
+import { buildSetupWizardDurableReceiptsFromReadModel, mergeSetupWizardDurableReceipts } from '../agent/setup-wizard-artifact-receipts.ts';
+import type { AgentSetupWizardDurableReceipt } from '../agent/setup-wizard.ts';
+
+interface SetupReceiptReadModelSource {
+  readonly path: string;
+  readonly source: unknown;
+}
+
+function readRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function setupReceiptReadModelSources(context: CommandContext): readonly SetupReceiptReadModelSource[] {
+  const contextRecord = context as unknown as Record<string, unknown>;
+  const platform = readRecord(contextRecord.platform);
+  const clients = readRecord(contextRecord.clients);
+  const readModels = readRecord(platform.readModels);
+  const setup = readRecord(readModels.setup);
+  const setupWizard = readRecord(readModels.setupWizard);
+  const firstRun = readRecord(readModels.firstRun);
+  const browserPwa = readRecord(readModels.browserPwa);
+  const operator = readRecord(clients.operator);
+  return [
+    { path: 'context.platform.readModels.setup.receipts', source: setup.receipts },
+    { path: 'context.platform.readModels.setup.setupReceipts', source: setup.setupReceipts },
+    { path: 'context.platform.readModels.setup.receiptEvents', source: setup.receiptEvents },
+    { path: 'context.platform.readModels.setup.eventStream', source: setup.eventStream },
+    { path: 'context.platform.readModels.setup', source: readModels.setup },
+    { path: 'context.platform.readModels.setupWizard.receipts', source: setupWizard.receipts },
+    { path: 'context.platform.readModels.setupWizard.durableReceipts', source: setupWizard.durableReceipts },
+    { path: 'context.platform.readModels.setupWizard.receiptEvents', source: setupWizard.receiptEvents },
+    { path: 'context.platform.readModels.setupWizard.eventStream', source: setupWizard.eventStream },
+    { path: 'context.platform.readModels.setupReceipts', source: readModels.setupReceipts },
+    { path: 'context.platform.readModels.setupReceiptEvents', source: readModels.setupReceiptEvents },
+    { path: 'context.platform.readModels.setupReceiptEventStream', source: readModels.setupReceiptEventStream },
+    { path: 'context.platform.readModels.durableSetupReceipts', source: readModels.durableSetupReceipts },
+    { path: 'context.platform.readModels.firstRun.receipts', source: firstRun.receipts },
+    { path: 'context.platform.readModels.browserPwa.firstRunReceipts', source: browserPwa.firstRunReceipts },
+    { path: 'context.platform.setupReceipts', source: platform.setupReceipts },
+    { path: 'context.platform.setupReceiptEvents', source: platform.setupReceiptEvents },
+    { path: 'context.clients.operator.setupReceipts', source: operator.setupReceipts },
+    { path: 'context.clients.operator.setupReceiptEvents', source: operator.setupReceiptEvents },
+  ];
+}
+
+function readSnapshot(source: unknown): unknown {
+  if (typeof source === 'function') {
+    const result = (source as () => unknown)();
+    return result instanceof Promise ? undefined : result;
+  }
+  const record = readRecord(source);
+  for (const methodName of ['getSnapshot', 'snapshot', 'list', 'listReceipts', 'listEvents', 'listReceiptEvents', 'readEvents']) {
+    const method = record[methodName];
+    if (typeof method === 'function') {
+      const result = (method as () => unknown)();
+      return result instanceof Promise ? undefined : result;
+    }
+  }
+  return source;
+}
+
+export function setupWizardLiveDurableReceipts(context: CommandContext): readonly AgentSetupWizardDurableReceipt[] {
+  const receipts: AgentSetupWizardDurableReceipt[][] = [];
+  for (const entry of setupReceiptReadModelSources(context)) {
+    if (entry.source === undefined || entry.source === null) continue;
+    try {
+      receipts.push([...buildSetupWizardDurableReceiptsFromReadModel(readSnapshot(entry.source), entry.path)]);
+    } catch {
+      // Broken host read models should not hide local setup posture.
+    }
+  }
+  return mergeSetupWizardDurableReceipts(...receipts);
+}
+
+export { mergeSetupWizardDurableReceipts };

package/src/main.ts

@@ -44,6 +44,7 @@ import type { SessionSnapshot } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
 import { createAgentWorkspaceFullscreenComposite, createFullscreenCompositeFromLines } from './shell/agent-workspace-fullscreen.ts';
 import { getTerminalSize } from './shell/terminal-size.ts';
+import { buildShellSessionContinuityHints } from './shell/session-continuity-hints.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
 import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
@@ -128,19 +129,12 @@ async function main() {
   }
 
   const panelManager = ctx.services.panelManager;
-  const buildSessionContinuityHints = () => {
-    const sessionSnapshot = uiServices.readModels.session.getSnapshot();
-    const tasksSnapshot = uiServices.readModels.tasks.getSnapshot();
-    const remoteSnapshot = uiServices.readModels.remote.getSnapshot();
-    return {
-      pendingApprovals: sessionSnapshot.pendingApproval ? 1 : 0,
-      activeTasks: tasksSnapshot.tasks.filter((task) => task.status === 'running' || task.status === 'queued').length,
-      blockedTasks: tasksSnapshot.tasks.filter((task) => task.status === 'blocked').length,
-      remoteContracts: remoteSnapshot.contracts.length,
-      remoteRunners: remoteSnapshot.contracts.slice(0, 4).map((contract) => contract.runnerId),
-      openPanels: panelManager.getAllOpen().map((panel) => panel.id),
-    };
-  };
+  const buildSessionContinuityHints = () => buildShellSessionContinuityHints(
+    uiServices.readModels.session.getSnapshot(),
+    uiServices.readModels.tasks.getSnapshot(),
+    uiServices.readModels.remote.getSnapshot(),
+    panelManager.getAllOpen(),
+  );
   const buildCurrentSessionSnapshot = (): SessionSnapshot => {
     const messages = conversation.getMessageSnapshot();
     const persisted = buildPersistedSessionContext(messages, conversation.getTitleSource(), buildSessionContinuityHints());
@@ -494,9 +488,13 @@ async function main() {
     // Cache the current model for consistent values across the entire render frame
     const currentModel = providerRegistry.getCurrentModel();
     const sessionSnapshot = uiServices.readModels.session.getSnapshot();
+    const agentSnapshot = uiServices.readModels.agents.getSnapshot();
+    const activeAgents = agentSnapshot.active;
+    const primaryActiveAgent = activeAgents.find((agent) => agent.latestProgress?.trim())
+      ?? activeAgents[0];
 
     const headerLines = UIFactory.createHeader(width, currentModel.id, currentModel.provider, conversation.title || undefined);
-    const runningAgentCount = 0;
+    const runningAgentCount = activeAgents.length;
     const runningProcessCount = processManager.list().filter((p) => !p.status.startsWith('done')).length;
     const cw = getPromptContentWidth();
     const promptInfo = input.getWrappedPromptInfo(cw);
@@ -543,7 +541,9 @@ async function main() {
       runningAgentCount,
       runningProcessCount,
       indicatorFocused: input.indicatorFocused,
-      runningAgentProgress: undefined,
+      runningAgentProgress: primaryActiveAgent
+        ? `${primaryActiveAgent.label}: ${primaryActiveAgent.latestProgress?.trim() || primaryActiveAgent.status}`
+        : undefined,
       composerMode: composerState.modeLabel,
       composerStatus: composerState.statusLabel,
       composerFlags: composerState.flags,

package/src/panels/qr-panel.ts

@@ -158,12 +158,12 @@ export class QrPanel extends BasePanel {
       );
       lines.push(
         buildPanelLine(width, [
-          [' Connected-host operator token is missing. Agent does not create or rotate host auth tokens. ', C.dim],
+          [' Connected-host operator token is missing. Use confirmed setup to create or repair it. ', C.dim],
         ]),
       );
       lines.push(
         buildPanelLine(width, [
-          [' Provision or repair connected-host access through the owning GoodVibes host, then reopen this panel. ', C.dim],
+          [' agent_harness mode:"provision_connected_host_token" then reopen this panel. ', C.dim],
         ]),
       );
     }