@pellux/goodvibes-agent 1.0.35 → 1.0.36

package/src/panels/builtin/shared.ts

@@ -95,7 +95,7 @@ export interface BuiltinPanelDeps {
   planManager?: ExecutionPlanManager;
   /** Adaptive planner for ops strategy panels. */
   adaptivePlanner?: AdaptivePlanner;
-  /** Passive SDK-backed project planning artifact service. */
+  /** Passive project planning artifact service. */
   projectPlanningService?: ProjectPlanningService;
   /** Stable workspace project id for project:<projectId> planning namespaces. */
   projectPlanningProjectId?: string;

package/src/panels/project-planning-panel.ts

@@ -192,7 +192,7 @@ export class ProjectPlanningPanel extends BasePanel {
           lines: buildEmptyState(
             width,
             'No project planning state has been saved for this workspace.',
-            'Describe the intended operator outcome in normal chat to let the Agent start the planning interview. The SDK stores and evaluates artifacts; it does not start execution.',
+            'Describe the intended operator outcome in normal chat to let the Agent start the planning interview. The planning artifact service stores and evaluates artifacts; it does not start execution.',
             [],
             C,
           ),
@@ -234,7 +234,7 @@ export class ProjectPlanningPanel extends BasePanel {
 
       return buildPanelWorkspace(width, height, {
         title: this.loading ? 'Project Planning - loading' : 'Project Planning',
-        intro: 'SDK-backed planning artifacts for the current Agent workspace. Conversation control stays in the main Agent turn.',
+        intro: 'Planning artifacts for the current Agent workspace. Conversation control stays in the main Agent turn.',
         sections: [{ ...scroll.section, lines: sectionLines }],
         footerLines: this.footerLines(width, footerSummary),
         palette: C,
@@ -557,8 +557,8 @@ export class ProjectPlanningPanel extends BasePanel {
       actions.push({
         id: 'scope-agent-first',
         label: 'Agent-first scope',
-        detail: 'Fix Agent behavior here; report SDK blockers instead of patching around SDK-owned bugs.',
-        answer: 'Scope is Agent-owned behavior first. If a blocker is SDK-owned, report the exact SDK contract/runtime issue instead of patching around it locally. Include runtime contracts only where Agent consumes public runtime routes.',
+        detail: 'Fix Agent behavior here; report public-runtime blockers instead of patching around external runtime bugs.',
+        answer: 'Scope is Agent-owned behavior first. If a blocker belongs to the public runtime, report the exact contract/runtime issue instead of patching around it locally. Include runtime contracts only where Agent consumes public runtime routes.',
       });
     }
     actions.push({

package/src/panels/qr-panel.ts

@@ -31,7 +31,7 @@ export interface QrPanelConnectionInfo {
   readonly username: string;
   /** Bootstrap password for companion authentication */
   readonly password?: string;
-  /** SDK/surface version (defaults to '0.0.0' if omitted) */
+  /** Pairing payload version (defaults to '0.0.0' if omitted) */
   readonly version?: string;
   /** Surface identifier (defaults to GoodVibes Agent if omitted) */
   readonly surface?: string;
@@ -54,7 +54,7 @@ export type CopyToClipboardFn = (text: string) => void;
  * Shows connection URL, truncated token, and username above the QR code.
  * Supports `r` to regenerate the token and `c` to copy the token.
  *
- * QR matrix generation uses the SDK's `generateQrMatrix` via `encodeConnectionPayload`.
+ * QR matrix generation uses `generateQrMatrix` via `encodeConnectionPayload`.
  */
 export class QrPanel extends BasePanel {
   private connectionInfo: QrPanelConnectionInfo;

package/src/renderer/conversation-overlays.ts

@@ -43,6 +43,7 @@ export function applyConversationOverlays(
   if (input.onboardingWizard.active) {
     const lines = renderOnboardingWizard(input.onboardingWizard, conversationWidth, viewportHeight);
     next = replaceViewportWithOverlay(lines, conversationWidth, viewportHeight);
+    if (!input.modelPicker.active) return next;
   }
 
   if (input.filePicker.active) {

package/src/runtime/bootstrap-command-parts.ts

@@ -133,7 +133,7 @@ export interface BootstrapCommandSectionOptions {
 }
 
 function unwiredShellAction(name: string): never {
-  throw new Error(`commandContext.${name} was called before the shell bridge was attached in main.ts`);
+  throw new Error(`Agent runtime action "${name}" was called before the operator route was attached.`);
 }
 
 export function createBootstrapCommandActions(

package/src/runtime/bootstrap-core.ts

@@ -149,7 +149,7 @@ export async function initializeBootstrapCore(
     metadata: {
       product: 'goodvibes-agent',
       surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
-      clientKindNote: 'SDK compatibility client kind; GoodVibes Agent remains an interactive operator TUI.',
+      clientKindNote: 'Connected-host client kind; GoodVibes Agent remains an interactive operator TUI.',
     },
   }, 'bootstrap.control-plane');
 

package/src/runtime/bootstrap-hook-bridge.ts

@@ -85,7 +85,7 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
         sessionId: options.runtime.sessionId,
         timestamp: Date.now(),
         payload: { sessionId },
-      }).catch((err: unknown) => logger.debug('Hook bridge fire error', {
+      }).catch((err: unknown) => logger.debug('Hook route fire error', {
         path: 'Lifecycle:session:load',
         error: summarizeError(err),
       }));

package/src/runtime/bootstrap-shell.ts

@@ -92,7 +92,7 @@ export function submitPlanningAnswerWithShellFallback(
     }
 
     options.addSystemMessage([
-      '[Planning] Could not submit the selected answer because the prompt bridge is not ready.',
+      '[Planning] Could not submit the selected answer because the prompt route is not ready.',
       `Paste this answer into the prompt to continue planning: ${answer}`,
     ].join('\n'));
     options.requestRender();

package/src/runtime/bootstrap.ts

@@ -50,6 +50,7 @@ const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '- Work serially in the main conversation by default: answer, inspect, summarize, remember useful non-secret facts, configure Agent-local state, and use safe read-only connected-host/operator routes.',
   '- Connected-host lifecycle is external. Do not start, stop, restart, install, expose, or mutate host listeners/network posture from Agent.',
   '- Read tools: `agent_operator_briefing` for connected work/approvals/automation/schedules, `agent_knowledge` for isolated Agent Knowledge, `agent_harness` for harness catalogs/settings/status.',
+  '- Harness access: use `agent_harness` modes `commands`/`run_command`, `workspace_actions`/`run_workspace_action`, and `settings`/`set_setting`/`reset_setting` to use the same surfaces the user can use.',
   '- State tools: `agent_work_plan` for visible local work items; `agent_local_registry` for Agent-local notes, memory, personas, skills, bundles, and routines. Keep records non-secret, sourced, and reviewable.',
   '- Confirmed tools: use `agent_operator_action`, `agent_knowledge_ingest`, `agent_media_generate`, `agent_notify`, `agent_channel_send`, and `agent_reminder_schedule` only for explicit user requests with confirm:true and explicitUserRequest.',
   '- Agent Knowledge must use only `/api/goodvibes-agent/knowledge/*` and fail closed. Do not use default knowledge or non-Agent knowledge spaces.',
@@ -89,9 +90,9 @@ export type BootstrapContext = RuntimeContext & {
   agentStatusIntervalRef: { value: ReturnType<typeof setInterval> | null };
   /** Mutable refs for viewport/scroll/render functions; main.ts patches these after constructing UI state. */
   orchestratorRefs: { getViewportHeight: () => number; scrollToEnd: (vHeight: number) => void; requestRender: () => void };
-  /** Patch the bootstrap-owned render bridge after main.ts constructs the real render loop. */
+  /** Patch the bootstrap-owned render route after main.ts constructs the real render loop. */
   setRenderRequest: (fn: () => void) => void;
-  /** Shell-owned permission prompt bridge that main.ts patches after UI setup. */
+  /** Shell-owned permission prompt route that main.ts patches after UI setup. */
   permissionPromptRef: { requestPermission: PermissionRequestHandler };
   /** Load the most recently saved conversation from disk. */
   loadLastConversation: () => { messages: Array<Record<string, unknown>> } | null;
@@ -130,7 +131,7 @@ export type BootstrapContext = RuntimeContext & {
  *   1. Config, caches, keybindings
  *   2. Runtime event bus, conversation, compositor, selection
  *   3. Tool registry + agent wiring
- *   4. Runtime bus subscriptions (delegation, subagent, hook bridge)
+ *   4. Runtime bus subscriptions (delegation, subagent, hook route)
  *   5. Providers, webhooks, PermissionManager, HookDispatcher
  *   6. Orchestrator and Agent-local task read models
  *   7. MCP auto-connect + workspace/panel manager
@@ -547,7 +548,7 @@ export async function bootstrapRuntime(
     },
   };
 
-  // Wire exit from options if provided; otherwise main.ts binds the shell bridge.
+  // Wire exit from options if provided; otherwise main.ts binds the operator route.
   if (options?.exit) {
     ctx.commandContext.exit = options.exit;
   }

package/src/runtime/context.ts

@@ -35,8 +35,8 @@ export interface BootstrapOptions {
   configManager: import('@pellux/goodvibes-sdk/platform/config').ConfigManager;
   /**
    * Callback invoked when the app should exit.
-   * If provided, commandContext.exit is wired during bootstrap.
-   * Otherwise main.ts binds the shell-owned exit bridge immediately after bootstrap returns.
+   * If provided, the exit route is wired during bootstrap.
+   * Otherwise main.ts binds the app-owned exit route immediately after bootstrap returns.
    */
   exit?: () => void;
 }

package/src/runtime/index.ts

@@ -1,8 +1,8 @@
 /**
  * Runtime module barrel for GoodVibes Agent.
  *
- * SDK 0.33 intentionally removed private deep imports and the runtime root
- * god-barrel. This file keeps the Agent app on public SDK seams
+ * The shared runtime removed private deep imports and the runtime root
+ * god-barrel. This file keeps the Agent app on public runtime exports
  * while preserving the local import surface used by the shell.
  */
 
@@ -50,7 +50,7 @@ export function createFeatureFlagManager(): FeatureFlagManager {
   return manager;
 }
 
-// Public SDK runtime seams.
+// Public runtime exports.
 export * from '@pellux/goodvibes-sdk/platform/runtime/state';
 export * from '@pellux/goodvibes-sdk/platform/runtime/store';
 export * from '@pellux/goodvibes-sdk/platform/runtime/ui';
@@ -491,8 +491,6 @@ export const canonicalize = security.canonicalize;
 export const classifyCommand = security.classifyCommand;
 export const classifySegment = security.classifySegment;
 export const collectCommandNodes = security.collectCommandNodes;
-export const evaluateCommandAST = security.evaluateCommandAST;
-export const evaluateSegmentNode = security.evaluateSegmentNode;
 export const higherPriority = security.higherPriority;
 export const parseAST = security.parseAST;
 export const parseCommandAST = security.parseCommandAST;
@@ -505,6 +503,91 @@ export const verifyBundle = security.verifyBundle;
 export const MAX_INPUT_LENGTH = security.MAX_INPUT_LENGTH;
 export const MAX_TOKEN_COUNT = security.MAX_TOKEN_COUNT;
 
+type RuntimeSegmentVerdict = ReturnType<typeof security.evaluateSegmentNode>;
+type RuntimeCompoundVerdict = ReturnType<typeof security.evaluateCommandAST>;
+type RuntimeShellNode = Parameters<typeof security.evaluateCommandAST>[1];
+
+const AGENT_OBFUSCATION_CHECKS: Array<{ description: string; test: (raw: string) => boolean }> = [
+  {
+    description: 'base64-encoded argument (possible command injection)',
+    test: (raw) =>
+      extractInspectableShellWords(raw).some((word) =>
+        /^[A-Za-z0-9+/]+={0,2}$/.test(word) && word.length >= 12 && word.length % 4 === 0,
+      ),
+  },
+  {
+    description: 'URL-encoded content in argument',
+    test: (raw) => /%[0-9a-fA-F]{2}/.test(raw),
+  },
+];
+
+function extractInspectableShellWords(raw: string): string[] {
+  return (raw.match(/"[^"]*"|'[^']*'|`[^`]*`|\S+/g) ?? []).map((word) =>
+    word.replace(/^["'`]+|["'`;|&]+$/g, ''),
+  );
+}
+
+function agentObfuscationPatterns(raw: string, existing: readonly string[]): string[] {
+  const patterns = new Set(existing);
+  for (const check of AGENT_OBFUSCATION_CHECKS) {
+    if (check.test(raw)) {
+      patterns.add(check.description);
+    }
+  }
+  return [...patterns];
+}
+
+function enforceAgentObfuscationVerdict(verdict: RuntimeSegmentVerdict): RuntimeSegmentVerdict {
+  const obfuscationPatterns = agentObfuscationPatterns(verdict.raw, verdict.obfuscationPatterns);
+  if (obfuscationPatterns.length === verdict.obfuscationPatterns.length) {
+    return verdict;
+  }
+
+  return {
+    ...verdict,
+    allowed: false,
+    reason: `obfuscation detected: ${obfuscationPatterns.join('; ')}`,
+    hasObfuscation: true,
+    obfuscationPatterns,
+  };
+}
+
+export function evaluateSegmentNode(
+  node: Security.CommandNode,
+  allowedClasses?: ReadonlySet<Security.CommandClassification>,
+): RuntimeSegmentVerdict {
+  const verdict = allowedClasses === undefined
+    ? security.evaluateSegmentNode(node)
+    : security.evaluateSegmentNode(node, allowedClasses);
+  return enforceAgentObfuscationVerdict(verdict);
+}
+
+export function evaluateCommandAST(
+  original: string,
+  ast: RuntimeShellNode,
+  allowedClasses?: ReadonlySet<Security.CommandClassification>,
+): RuntimeCompoundVerdict {
+  const compound = allowedClasses === undefined
+    ? security.evaluateCommandAST(original, ast)
+    : security.evaluateCommandAST(original, ast, allowedClasses);
+  const segments = compound.segments.map(enforceAgentObfuscationVerdict);
+  const allowed = segments.every((segment) => segment.allowed);
+  const hasObfuscation = segments.some((segment) => segment.hasObfuscation);
+
+  const next: RuntimeCompoundVerdict = {
+    ...compound,
+    allowed,
+    segments,
+    hasObfuscation,
+  };
+  if (allowed) {
+    delete next.denialExplanation;
+  } else {
+    next.denialExplanation = security.buildDenialExplanation(original, segments);
+  }
+  return next;
+}
+
 export type AuthInspectionSnapshot = Security.AuthInspectionSnapshot;
 export type ProviderAuthInspection = Security.ProviderAuthInspection;
 export type DivergenceDashboardSnapshot = Security.DivergenceDashboardSnapshot;

package/src/runtime/store/state.ts

@@ -34,7 +34,7 @@ import type { DiscoveryDomainState } from '@/runtime/index.ts';
 import type { IntelligenceDomainState } from '@/runtime/index.ts';
 import type { UiPerfDomainState } from './domains/ui-perf.ts';
 // UiPerfDomainState is structurally identical to SDK's SurfacePerfDomainState.
-// Export as SurfacePerfDomainState alias for SDK compatibility.
+// Export as SurfacePerfDomainState alias for shared runtime callers.
 export type { UiPerfDomainState };
 
 import { createInitialSessionState } from '@/runtime/index.ts';

package/src/tools/agent-channel-send-tool.ts

@@ -75,7 +75,7 @@ export function createAgentChannelSendTool(
           },
           explicitUserRequest: {
             type: 'string',
-            description: 'Short quote or summary of the user request that authorized this delivery.',
+            description: 'User request authorizing this delivery.',
           },
         },
         required: ['message', 'confirm', 'explicitUserRequest'],

package/src/tools/agent-harness-channel-metadata.ts

@@ -1,6 +1,7 @@
 import type { CommandContext } from '../input/command-registry.ts';
 import type { AgentWorkspaceChannelStatus } from '../input/agent-workspace-channels.ts';
 import { buildAgentWorkspaceChannels } from '../input/agent-workspace-channels.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessChannelArgs {
   readonly channelId?: unknown;
@@ -59,9 +60,14 @@ function describeChannelCandidate(channel: AgentWorkspaceChannelStatus): Record<
     setupState: channel.setupState,
     ready: channel.ready,
     delivery: channel.delivery,
+    modelRoute: channelModelRoute(),
   };
 }
 
+function channelModelRoute(): string {
+  return 'agent_channel_send or agent_harness mode:"channel"';
+}
+
 function describeChannel(
   channel: AgentWorkspaceChannelStatus,
   options: { readonly includeParameters?: boolean; readonly lookup?: Record<string, unknown> } = {},
@@ -82,32 +88,37 @@ function describeChannel(
     missingConfigKeys: channel.missingRequiredKeys,
     defaultTargetKeys: channel.defaultTargetKeys,
     configuredDefaultTargetKeys: channel.configuredDefaultTargetKeys,
+    modelRoute: channelModelRoute(),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    ...(options.includeParameters ? {
-      policy: {
-        effect: 'read-only',
-        values: 'Config key names and target key names are shown; secret values and stored target values are never returned.',
-        delivery: 'Use agent_channel_send only for one explicit, confirmed delivery target requested by the user.',
-        setup: 'Use connected-host setup/account/policy routes only as read-only diagnostics unless another confirmed first-class tool owns the mutation.',
-      },
-      modelAccess: {
-        sendTool: 'agent_channel_send',
-        notificationTool: 'agent_notify',
-        reminderTool: 'agent_reminder_schedule',
-        slashCommandDetail: `/channels show ${channel.id}`,
-        readOnlyConnectedRoutes: [
-          '/channels accounts',
-          '/channels policies',
-          '/channels status',
-          `/channels doctor ${channel.id}`,
-          `/channels setup ${channel.id}`,
-        ],
-        settingsFilter: `agent_harness mode:"settings" prefix:"surfaces.${channel.id}" includeHidden:true`,
-        connectedHostBoundary: 'agent_harness mode:"connected_host_capability" query:"delivery"',
-        deliveryTargetShape: 'surface[:route[:label]]',
-        exampleTarget: `${channel.id}:route:Label`,
-      },
-    } : {}),
+    ...(options.includeParameters
+      ? {
+        policy: {
+          effect: 'read-only',
+          values: 'Config key names and target key names are shown; secret values and stored target values are never returned.',
+          delivery: 'Use agent_channel_send only for one explicit, confirmed delivery target requested by the user.',
+          setup: 'Use connected-host setup/account/policy routes only as read-only diagnostics unless another confirmed first-class tool owns the mutation.',
+        },
+        modelAccess: {
+          sendTool: 'agent_channel_send',
+          notificationTool: 'agent_notify',
+          reminderTool: 'agent_reminder_schedule',
+          slashCommandDetail: `/channels show ${channel.id}`,
+          readOnlyConnectedRoutes: [
+            '/channels accounts',
+            '/channels policies',
+            '/channels status',
+            `/channels doctor ${channel.id}`,
+            `/channels setup ${channel.id}`,
+          ],
+          settingsFilter: `agent_harness mode:"settings" prefix:"surfaces.${channel.id}" includeHidden:true`,
+          connectedHostBoundary: 'agent_harness mode:"connected_host_capability" query:"delivery"',
+          deliveryTargetShape: 'surface[:route[:label]]',
+          exampleTarget: `${channel.id}:route:Label`,
+        },
+      }
+      : {
+        summary: previewHarnessText(channel.nextStep || `${channel.label} channel ${channel.setupState}`),
+      }),
   };
 }
 

package/src/tools/agent-harness-cli-metadata.ts

@@ -34,6 +34,11 @@ function readLimit(value: unknown, fallback: number): number {
   return Math.max(1, Math.min(500, Math.trunc(parsed)));
 }
 
+function previewText(value: string, maxLength = 56): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}
+
 function redactCliLookupInput(input: string): string {
   return input
     .replace(/(--config=)([^=\s]+)=\S+/g, '$1$2=<redacted>')
@@ -58,6 +63,8 @@ function fallbackCliSummary(command: GoodVibesCliCommand): string {
 function describeCliCommand(command: GoodVibesCliCommand, lookup?: CliCommandLookup): Record<string, unknown> {
   const help = describeGoodVibesCommandHelp(command);
   const tokens = cliCommandTokens(command);
+  const policy = describeCliCommandPolicy(command);
+  const modelRoute = previewText(policy.preferredModelTool ?? 'agent_harness mode:"cli_command"');
   return {
     name: command,
     tokens,
@@ -69,7 +76,13 @@ function describeCliCommand(command: GoodVibesCliCommand, lookup?: CliCommandLoo
     aliases: help?.aliases ?? tokens.filter((token) => token !== command),
     subcommands: help?.subcommands ?? [],
     examples: help?.examples ?? [],
-    policy: describeCliCommandPolicy(command),
+    modelRoute,
+    modelAccess: {
+      inspect: `agent_harness mode:"cli_command" cliCommand:"${command}"`,
+      executeEquivalent: policy.preferredModelTool ?? 'Use the current conversation or an explicit user-requested shell command.',
+      preferred: modelRoute,
+    },
+    policy,
   };
 }
 
@@ -88,11 +101,16 @@ function cliCommandMatches(command: Record<string, unknown>, query: string): boo
 }
 
 function cliCommandCandidate(command: Record<string, unknown>): Record<string, unknown> {
+  const policy = typeof command.policy === 'object' && command.policy !== null
+    ? command.policy as { readonly effect?: unknown; readonly preferredModelTool?: unknown }
+    : {};
   return {
     name: command.name,
     tokens: command.tokens,
     invocation: command.invocation,
     summary: command.summary,
+    effect: typeof policy.effect === 'string' ? policy.effect : 'unknown',
+    ...(typeof policy.preferredModelTool === 'string' ? { modelRoute: previewText(policy.preferredModelTool) } : {}),
   };
 }
 

package/src/tools/agent-harness-command-catalog.ts

@@ -39,9 +39,9 @@ function readStringArray(value: unknown): readonly string[] {
   return value.map((entry) => typeof entry === 'string' ? entry : String(entry));
 }
 
-function previewText(value: string, maxLength = 120): string {
+function previewText(value: string, maxLength = 56): string {
   const normalized = value.replace(/\s+/g, ' ').trim();
-  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 1).trimEnd()}...`;
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
 }
 
 function commandMatches(command: SlashCommand, query: string): boolean {
@@ -57,6 +57,8 @@ function commandMatches(command: SlashCommand, query: string): boolean {
 }
 
 function describeCommand(command: SlashCommand, lookup?: CommandDetailLookup): Record<string, unknown> {
+  const policy = describeCommandPolicy(command.name);
+  const modelRoute = previewText(policy.preferredModelTool ?? 'agent_harness mode:"command", mode:"run_command"');
   return {
     name: command.name,
     slash: `/${command.name}`,
@@ -64,6 +66,12 @@ function describeCommand(command: SlashCommand, lookup?: CommandDetailLookup): R
     description: command.description,
     usage: command.usage ?? '',
     argsHint: command.argsHint ?? command.usage ?? '',
+    modelRoute,
+    modelAccess: {
+      inspect: `agent_harness mode:"command" commandName:"${command.name}"`,
+      run: `agent_harness mode:"run_command" commandName:"${command.name}" confirm:true explicitUserRequest:"..."`,
+      preferred: modelRoute,
+    },
     ...(lookup ? {
       lookup: {
         source: lookup.source,
@@ -73,16 +81,19 @@ function describeCommand(command: SlashCommand, lookup?: CommandDetailLookup): R
         resolvedBy: lookup.resolvedBy,
       },
     } : {}),
-    policy: describeCommandPolicy(command.name),
+    policy,
   };
 }
 
 function describeCommandCandidate(command: SlashCommand): Record<string, unknown> {
+  const policy = describeCommandPolicy(command.name);
   return {
     name: command.name,
     slash: `/${command.name}`,
     aliases: command.aliases ?? [],
     summary: previewText(command.description),
+    effect: policy.effect,
+    modelRoute: previewText(policy.preferredModelTool ?? 'agent_harness mode:"command", mode:"run_command"'),
     ...(command.argsHint ? { argsHint: command.argsHint } : {}),
   };
 }
@@ -170,7 +181,7 @@ export function resolveHarnessCommandDetail(commandRegistry: CommandRegistry, ar
 
 export function listHarnessCommands(commandRegistry: CommandRegistry, args: AgentHarnessCommandCatalogArgs): readonly Record<string, unknown>[] {
   const query = readString(args.query);
-  const limit = readLimit(args.limit, 200);
+  const limit = readLimit(args.limit, 500);
   const includeParameters = args.includeParameters === true;
   return commandRegistry.list()
     .filter((command) => commandMatches(command, query))

package/src/tools/agent-harness-connected-host-status.ts

@@ -39,11 +39,11 @@ function connectedHostFindings(
     });
   } else if (!runtime.compatible) {
     findings.push({
-      id: 'connected-host-version-mismatch',
+      id: 'connected-host-incompatible',
       severity: 'warning',
-      summary: 'Connected host SDK version does not match Agent.',
-      cause: `Connected host reports SDK ${runtime.version}; Agent expects ${runtime.expectedVersion}.`,
-      action: 'Update the owning GoodVibes host so its /status route reports the Agent SDK pin.',
+      summary: 'Connected host compatibility does not satisfy Agent readiness.',
+      cause: 'Connected host is reachable, but at least one public Agent route is unavailable or incompatible.',
+      action: 'Update the owning GoodVibes host so its public Agent routes are compatible.',
     });
   }
 
@@ -88,6 +88,7 @@ export async function connectedHostStatusSummary(
   return {
     ownership: 'external-connected-host',
     readOnly: true,
+    modelRoute: 'agent_harness mode:"connected_host_status" or mode:"service_posture"',
     timeoutMs: CONNECTED_HOST_STATUS_TIMEOUT_MS,
     lifecycle: 'GoodVibes Agent can inspect connected-host readiness and use public operator routes, but does not start, stop, restart, install, expose, or mutate the host listener.',
     paths: {
@@ -122,8 +123,6 @@ export async function connectedHostStatusSummary(
         route: '/status',
         reachable: runtime.reachable,
         statusCode: runtime.statusCode,
-        sdkVersion: runtime.version,
-        expectedSdkVersion: runtime.expectedVersion,
         compatible: runtime.compatible,
       },
       {
@@ -142,6 +141,8 @@ export async function connectedHostStatusSummary(
     },
     ...(options.includeParameters ? { modelAccess: {
       diagnostics: 'Use mode:"connected_host_status" for live read-only host readiness, mode:"service_posture" for endpoint posture, mode:"service_endpoint" for one endpoint, and mode:"connected_host" for capability and boundary inventory.',
+      daemonAliases: 'mode:"daemon_status" is an alias for mode:"connected_host_status"; mode:"daemon" is an alias for mode:"connected_host".',
+      lifecycleBlocked: 'Start, stop, restart, install, expose, and listener mutation are not exposed through Agent.',
       cliMirrors: ['goodvibes-agent status --json', 'goodvibes-agent doctor', 'goodvibes-agent compat'],
       tuiMirrors: ['Agent Workspace -> Home -> Host compatibility', 'Agent Workspace -> Home -> Doctor diagnostics', 'Agent Workspace -> Home -> Review health'],
     },

package/src/tools/agent-harness-delegation-posture.ts

@@ -1,4 +1,5 @@
 import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessDelegationArgs {
   readonly delegationRouteId?: unknown;
@@ -113,9 +114,16 @@ function describeCandidate(route: DelegationRoute): Record<string, unknown> {
     label: route.label,
     effect: route.effect,
     confirmationRequired: route.confirmationRequired === true,
+    modelRoute: delegationRouteModelRoute(route),
   };
 }
 
+function delegationRouteModelRoute(route: DelegationRoute): string {
+  if (route.workspaceActionId) return 'agent_harness mode:"run_workspace_action"';
+  if (route.command || route.commandTemplate) return 'agent_harness mode:"run_command"';
+  return route.effect === 'main-conversation' ? 'main conversation' : 'agent_harness mode:"delegation_route"';
+}
+
 function describeRoute(
   context: CommandContext,
   route: DelegationRoute,
@@ -124,17 +132,20 @@ function describeRoute(
   return {
     delegationRouteId: route.id,
     label: route.label,
-    detail: route.detail,
+    ...(options.includeParameters ? { detail: route.detail } : { summary: previewHarnessText(route.detail) }),
     effect: route.effect,
-    ...(route.command ? { command: route.command } : {}),
-    ...(route.commandTemplate ? { commandTemplate: route.commandTemplate } : {}),
-    ...(route.workspaceActionId ? { workspaceActionId: route.workspaceActionId } : {}),
     confirmationRequired: route.confirmationRequired === true,
     reviewPolicy: route.reviewPolicy ?? 'not-applicable',
+    modelRoute: delegationRouteModelRoute(route),
     runtime: {
       sessionId: context.session.runtime.sessionId,
       operatorClientAttached: Boolean(context.clients?.operator),
     },
+    ...(options.includeParameters ? {
+      ...(route.command ? { command: route.command } : {}),
+      ...(route.commandTemplate ? { commandTemplate: route.commandTemplate } : {}),
+      ...(route.workspaceActionId ? { workspaceActionId: route.workspaceActionId } : {}),
+    } : {}),
     ...(options.lookup ? { lookup: options.lookup } : {}),
     ...(options.includeParameters ? {
       policy: {