@pellux/goodvibes-agent 1.0.34 → 1.0.36

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

@@ -4,6 +4,7 @@ import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../config/surface.ts';
 import { resolveRuntimeEndpointBinding } from '../cli/endpoints.ts';
 import { connectedHostOperatorTokenFingerprint, readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 import { requirePlatform, requireShellPaths } from '../input/commands/runtime-services.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessPairingArgs {
   readonly pairingRouteId?: unknown;
@@ -101,7 +102,7 @@ function pairingRoutes(): readonly PairingRoute[] {
     {
       id: 'connected-host-status',
       label: 'Connected host live posture',
-      detail: 'Read-only reachability, token posture, SDK compatibility, and route readiness used before companion setup.',
+      detail: 'Read-only reachability, token posture, and route readiness used before companion setup.',
       effect: 'read-only',
       harnessRoute: 'agent_harness mode:"connected_host_status"',
       capabilityIds: ['connected-host-status'],
@@ -152,6 +153,7 @@ function describeCandidate(route: PairingRoute): Record<string, unknown> {
     label: route.label,
     effect: route.effect,
     requiresConfirmation: route.requiresConfirmation === true,
+    modelRoute: pairingRouteModelRoute(route),
   };
 }
 
@@ -159,12 +161,15 @@ function describeRoute(route: PairingRoute, options: { readonly includeParameter
   return {
     pairingRouteId: 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.harnessRoute ? { harnessRoute: route.harnessRoute } : {}),
-    ...(route.capabilityIds ? { capabilityIds: route.capabilityIds } : {}),
     requiresConfirmation: route.requiresConfirmation === true,
+    modelRoute: pairingRouteModelRoute(route),
+    ...(options.includeParameters ? {
+      ...(route.command ? { command: route.command } : {}),
+      ...(route.harnessRoute ? { harnessRoute: route.harnessRoute } : {}),
+      ...(route.capabilityIds ? { capabilityIds: route.capabilityIds } : {}),
+    } : {}),
     ...(options.lookup ? { lookup: options.lookup } : {}),
     ...(options.includeParameters ? {
       policy: {
@@ -183,6 +188,13 @@ function describeRoute(route: PairingRoute, options: { readonly includeParameter
   };
 }
 
+function pairingRouteModelRoute(route: PairingRoute): string {
+  if (route.command === '/pair') return 'agent_harness mode:"run_command" command:"/pair"';
+  if (route.command === '/pair --show-token --yes') return 'agent_harness mode:"run_command" command:"/pair --show-token --yes"';
+  if (route.id === 'pairing-ui') return 'agent_harness mode:"workspace_action" target:"pair"';
+  return previewHarnessText(route.harnessRoute ?? 'agent_harness mode:"pairing_route"');
+}
+
 function pairingState(context: CommandContext): Record<string, unknown> {
   const shellPaths = requireShellPaths(context);
   const configManager = requirePlatform(context).configManager;

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

@@ -40,9 +40,9 @@ function readLimit(value: unknown, fallback: number): number {
   return Math.max(1, Math.min(500, Math.trunc(parsed)));
 }
 
-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 panelManager(context: CommandContext) {
@@ -77,6 +77,7 @@ function panelCandidate(registration: PanelRegistration): Record<string, unknown
     name: registration.name,
     category: registration.category,
     summary: previewText(registration.description),
+    modelRoute: panelModelRoute(),
     workspaceRoute: {
       categoryId: agentWorkspaceCategoryForPanel(registration.id),
       command: agentWorkspaceCommandForPanel(registration.id),
@@ -84,6 +85,10 @@ function panelCandidate(registration: PanelRegistration): Record<string, unknown
   };
 }
 
+function panelModelRoute(): string {
+  return 'agent_harness mode:"open_panel" or mode:"workspace_actions"';
+}
+
 function resolveHarnessPanel(context: CommandContext, args: AgentHarnessPanelArgs): PanelResolution | null {
   const manager = panelManager(context);
   const lookup = panelLookupFromArgs(args);
@@ -131,6 +136,7 @@ function describePanelRegistration(
     pane,
     active: activePanel?.id === registration.id,
     focused: activePanel?.id === registration.id,
+    modelRoute: panelModelRoute(),
     workspaceRoute: {
       categoryId: agentWorkspaceCategoryForPanel(registration.id),
       command: agentWorkspaceCommandForPanel(registration.id),
@@ -139,7 +145,7 @@ function describePanelRegistration(
       policy: {
         effect: 'ui-navigation',
         confirmation: 'agent_harness mode:"open_panel" requires confirm:true and explicitUserRequest.',
-        boundary: 'Panels are Agent/TUI operator views. The model can inspect panel catalog/open state; panel routing uses the existing Agent workspace bridge and does not mutate connected-host lifecycle.',
+        boundary: 'Panels are Agent/TUI operator views. The model can inspect panel catalog/open state; panel routing uses the existing Agent workspace route and does not mutate connected-host lifecycle.',
       },
     } : {}),
   };
@@ -200,6 +206,6 @@ export function openHarnessPanel(context: CommandContext, args: AgentHarnessPane
     status: 'routed',
     panel,
     pane: pane ?? 'default',
-    note: 'Panel routing was handed to the current Agent shell bridge.',
+    note: 'Panel routing was handed to the current Agent operator surface.',
   };
 }

package/src/tools/agent-harness-provider-account-metadata.ts

@@ -2,6 +2,7 @@ import type { CommandContext } from '../input/command-registry.ts';
 import type { ProviderAccountRecord, ProviderAccountSnapshot } from '../panels/provider-account-snapshot.ts';
 import { buildProviderAccountSnapshot } from '../panels/provider-account-snapshot.ts';
 import { requireProvider, requireServiceRegistry, requireSubscriptionManager } from '../input/commands/runtime-services.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessProviderAccountArgs {
   readonly providerId?: unknown;
@@ -74,9 +75,14 @@ function describeCandidate(account: ProviderAccountRecord): Record<string, unkno
     authFreshness: account.authFreshness,
     configured: account.configured,
     issues: account.issues.length,
+    modelRoute: providerAccountModelRoute(),
   };
 }
 
+function providerAccountModelRoute(): string {
+  return 'agent_harness mode:"provider_account" or mode:"run_command"';
+}
+
 function describeAccount(
   account: ProviderAccountRecord,
   options: { readonly includeParameters?: boolean; readonly lookup?: Record<string, unknown> } = {},
@@ -99,42 +105,47 @@ function describeAccount(
     ...(account.tokenType ? { tokenType: account.tokenType } : {}),
     issueCount: account.issues.length,
     recommendedActionCount: account.recommendedActions.length,
+    modelRoute: providerAccountModelRoute(),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    ...(options.includeParameters ? {
-      routeRecords: account.routeRecords.map((route) => ({
-        route: route.route,
-        usable: route.usable,
-        freshness: route.freshness,
-        detail: route.detail,
-        issues: route.issues,
-      })),
-      usageWindows: account.usageWindows,
-      issues: account.issues,
-      notes: account.notes,
-      recommendedActions: account.recommendedActions,
-      policy: {
-        effect: 'read-only',
-        values: 'Provider account posture reports route and freshness metadata only; raw tokens, authorization codes, and secret values are never returned.',
-        mutation: 'Provider login, logout, subscription bundle export, and account repair actions stay explicit confirmation-gated workspace or slash-command flows.',
-      },
-      modelAccess: {
-        reviewCommand: '/accounts review',
-        showCommand: `/accounts show ${account.providerId}`,
-        routesCommand: `/accounts routes ${account.providerId}`,
-        repairCommand: `/accounts repair ${account.providerId}`,
-        subscriptionInspectCommand: `/subscription inspect ${account.providerId}`,
-        workspaceActions: [
-          'provider-accounts',
-          'provider-account-repair',
-          'subscription-review',
-          'subscription-inspect',
-        ],
-        loginStartCommand: `/subscription login ${account.providerId} start --yes`,
-        loginFinishCommand: `/subscription login ${account.providerId} finish <code-or-url> --yes`,
-        logoutCommand: `/subscription logout ${account.providerId} --yes`,
-        confirmationRequired: true,
-      },
-    } : {}),
+    ...(options.includeParameters
+      ? {
+        routeRecords: account.routeRecords.map((route) => ({
+          route: route.route,
+          usable: route.usable,
+          freshness: route.freshness,
+          detail: route.detail,
+          issues: route.issues,
+        })),
+        usageWindows: account.usageWindows,
+        issues: account.issues,
+        notes: account.notes,
+        recommendedActions: account.recommendedActions,
+        policy: {
+          effect: 'read-only',
+          values: 'Provider account posture reports route and freshness metadata only; raw tokens, authorization codes, and secret values are never returned.',
+          mutation: 'Provider login, logout, subscription bundle export, and account repair actions stay explicit confirmation-gated workspace or slash-command flows.',
+        },
+        modelAccess: {
+          reviewCommand: '/accounts review',
+          showCommand: `/accounts show ${account.providerId}`,
+          routesCommand: `/accounts routes ${account.providerId}`,
+          repairCommand: `/accounts repair ${account.providerId}`,
+          subscriptionInspectCommand: `/subscription inspect ${account.providerId}`,
+          workspaceActions: [
+            'provider-accounts',
+            'provider-account-repair',
+            'subscription-review',
+            'subscription-inspect',
+          ],
+          loginStartCommand: `/subscription login ${account.providerId} start --yes`,
+          loginFinishCommand: `/subscription login ${account.providerId} finish <code-or-url> --yes`,
+          logoutCommand: `/subscription logout ${account.providerId} --yes`,
+          confirmationRequired: true,
+        },
+      }
+      : {
+        summary: previewHarnessText(`${account.providerId} ${account.authFreshness}; ${account.issues.length} issue(s)`),
+      }),
   };
 }
 

package/src/tools/agent-harness-release-evidence.ts

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 const RELEASE_EVIDENCE_ARTIFACTS = [
   {
     id: 'release-notes',
     path: 'release/release-notes.md',
     kind: 'markdown',
-    description: 'Product-facing release notes for the current release evidence bundle.',
+    description: 'Shipped release notes included with operator/audit release artifacts.',
   },
   {
     id: 'performance-snapshot',
@@ -18,7 +19,7 @@ const RELEASE_EVIDENCE_ARTIFACTS = [
     id: 'release-readiness',
     path: 'release/release-readiness.json',
     kind: 'json',
-    description: 'Release capability inventory with owner, evidence, and quality dimensions.',
+    description: 'Release inventory with owner, evidence, and quality dimensions.',
   },
   {
     id: 'live-verification-json',
@@ -120,6 +121,20 @@ function artifactSearchText(artifact: ReleaseEvidenceArtifact): string {
   return `${artifact.id}\n${artifact.path}\n${artifact.kind}\n${artifact.description}`.toLowerCase();
 }
 
+function releaseEvidenceModelRoute(artifact?: ReleaseEvidenceArtifact): string {
+  if (artifact) return 'agent_harness mode:"release_evidence_artifact"';
+  return 'agent_harness mode:"release_evidence" or mode:"release_evidence_artifact"';
+}
+
+function releaseEvidencePolicy(): Record<string, unknown> {
+  return {
+    effect: 'operator-audit-read-only',
+    audience: 'release operators and maintainers',
+    values: 'Returns packaged release artifacts, summaries, and optional artifact content for release audit.',
+    boundary: 'Release artifacts are audit material. They are not visible product routes and do not mutate runtime state.',
+  };
+}
+
 function evidenceLookupFromArgs(args: ReleaseEvidenceArgs): ReleaseEvidenceLookup | null {
   const artifactId = readString(args.artifactId);
   if (artifactId) return { source: 'artifactId', input: artifactId };
@@ -243,6 +258,7 @@ function summarizeLoadedArtifact(
     kind: loaded.artifact.kind,
     description: loaded.artifact.description,
     status: loaded.status,
+    modelRoute: releaseEvidenceModelRoute(loaded.artifact),
   };
   if (loaded.status !== 'available') {
     return { ...base, reason: loaded.reason };
@@ -255,6 +271,12 @@ function summarizeLoadedArtifact(
     ...base,
     sizeBytes: loaded.sizeBytes,
     summary,
+    policy: releaseEvidencePolicy(),
+    modelAccess: {
+      listArtifacts: 'agent_harness mode:"release_evidence"',
+      inspectArtifact: `agent_harness mode:"release_evidence_artifact" artifactId:"${loaded.artifact.id}"`,
+      includeContent: 'Pass includeParameters:true only when release audit requires artifact content.',
+    },
     ...(options.includeSource
       ? loaded.artifact.kind === 'json'
         ? { data: loaded.parsed }
@@ -268,7 +290,8 @@ function releaseEvidenceCandidates(artifacts: readonly ReleaseEvidenceArtifact[]
     id: artifact.id,
     path: artifact.path,
     kind: artifact.kind,
-    description: artifact.description,
+    summary: previewHarnessText(artifact.description),
+    modelRoute: releaseEvidenceModelRoute(artifact),
   }));
 }
 
@@ -298,6 +321,11 @@ export function releaseEvidenceSummary(args: ReleaseEvidenceArgs): Record<string
     filtered: filtered.length,
     returned: loaded.length,
     artifactsList: loaded.map((artifact) => summarizeLoadedArtifact(artifact, { includeSource: args.includeParameters === true })),
+    policy: releaseEvidencePolicy(),
+    modelAccess: {
+      listArtifacts: 'agent_harness mode:"release_evidence"',
+      inspectArtifact: 'agent_harness mode:"release_evidence_artifact" with artifactId, target, or query',
+    },
     artifactLookup: 'Use mode:"release_evidence_artifact" with artifactId, target, or query to inspect one release evidence artifact.',
   };
 }

package/src/tools/agent-harness-release-readiness.ts

@@ -103,6 +103,20 @@ function itemSearchText(item: Record<string, unknown>): string {
   return fields.join('\n').toLowerCase();
 }
 
+function releaseReadinessModelRoute(item?: Record<string, unknown>): string {
+  if (item) return 'agent_harness mode:"release_readiness_item"';
+  return 'agent_harness mode:"release_readiness" or mode:"release_readiness_item"';
+}
+
+function releaseReadinessPolicy(): Record<string, unknown> {
+  return {
+    effect: 'operator-audit-read-only',
+    audience: 'release operators and maintainers',
+    values: 'Returns release-quality inventory status, evidence, and quality dimensions for audit.',
+    boundary: 'Release readiness is audit material. It is not a visible product route and does not mutate runtime state.',
+  };
+}
+
 function countBy(items: readonly Record<string, unknown>[], key: string): Record<string, number> {
   const counts: Record<string, number> = {};
   for (const item of items) {
@@ -134,7 +148,15 @@ function summarizeItem(item: Record<string, unknown>, options: { readonly includ
     status: item.status,
     evidence: item.evidence,
     action: item.action,
+    modelRoute: releaseReadinessModelRoute(item),
     ...(options.includeQuality ? { quality: item.quality } : {}),
+    ...(options.includeQuality ? {
+      policy: releaseReadinessPolicy(),
+      modelAccess: {
+        listItems: 'agent_harness mode:"release_readiness"',
+        inspectItem: `agent_harness mode:"release_readiness_item" itemId:"${readString(item.id)}"`,
+      },
+    } : {}),
   };
 }
 
@@ -153,6 +175,7 @@ function releaseReadinessCandidates(items: readonly Record<string, unknown>[]):
     capability: item.capability,
     owner: item.owner,
     status: item.status,
+    modelRoute: releaseReadinessModelRoute(item),
   }));
 }
 
@@ -173,6 +196,8 @@ export function releaseReadinessInventoryStatus(): Record<string, unknown> {
     checkedAt: loaded.root.checkedAt,
     items: items.length,
     qualityDimensions: QUALITY_DIMENSIONS,
+    modelRoute: releaseReadinessModelRoute(),
+    policy: releaseReadinessPolicy(),
   };
 }
 
@@ -203,6 +228,11 @@ export function releaseReadinessSummary(args: ReleaseReadinessArgs): Record<stri
     schemaVersion: loaded.root.schemaVersion,
     checkedAt: loaded.root.checkedAt,
     policy: loaded.root.policy,
+    operatorAuditPolicy: releaseReadinessPolicy(),
+    modelAccess: {
+      listItems: 'agent_harness mode:"release_readiness"',
+      inspectItem: 'agent_harness mode:"release_readiness_item" with itemId, target, or query',
+    },
     totals: {
       items: items.length,
       filtered: filtered.length,

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

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { buildMcpAttackPathReview } from '@/runtime/index.ts';
 import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessSecurityArgs {
   readonly query?: unknown;
@@ -153,9 +154,18 @@ function describeFindingCandidate(finding: SecurityFinding): Record<string, unkn
     source: finding.source,
     severity: finding.severity,
     title: finding.title,
+    modelRoute: securityFindingModelRoute(),
   };
 }
 
+function securityFindingModelRoute(): string {
+  return 'agent_harness mode:"security_finding" or mode:"run_command"';
+}
+
+function supportBundleModelRoute(): string {
+  return 'agent_harness mode:"support_bundle" or mode:"run_workspace_action"';
+}
+
 function describeFinding(finding: SecurityFinding, includeParameters: boolean, lookup?: Record<string, unknown>): Record<string, unknown> {
   return {
     findingId: finding.findingId,
@@ -164,6 +174,7 @@ function describeFinding(finding: SecurityFinding, includeParameters: boolean, l
     title: finding.title,
     summary: finding.summary,
     route: finding.route,
+    modelRoute: securityFindingModelRoute(),
     ...(lookup ? { lookup } : {}),
     ...(includeParameters && finding.detail ? { detail: finding.detail } : {}),
     ...(includeParameters ? {
@@ -537,15 +548,18 @@ export function supportBundleSummary(args: AgentHarnessSecurityArgs): Record<str
       bundleType: route.bundleType,
       defaultPath: route.defaultPath,
       inspectCommand: route.inspectCommand,
-      exportCommand: route.exportCommand,
-      ...(route.importCommand ? { importCommand: route.importCommand } : {}),
-      workspaceActionIds: route.workspaceActionIds,
+      modelRoute: supportBundleModelRoute(),
       ...(args.includeParameters === true ? {
+        exportCommand: route.exportCommand,
+        ...(route.importCommand ? { importCommand: route.importCommand } : {}),
+        workspaceActionIds: route.workspaceActionIds,
         parameters: {
           bundlePath: 'Workspace-relative path for support_bundle inspection.',
           confirm: 'Required for export/import routes through run_workspace_action or run_command.',
         },
-      } : {}),
+      } : {
+        summary: previewHarnessText(`${route.bundleType} bundle inspection route`),
+      }),
     }));
   return {
     bundles: routes,

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

@@ -77,13 +77,14 @@ function describeEndpoint(
     bindPosture: endpoint.bindPosture,
     networkFacing: endpoint.networkFacing,
     ...(endpoint.reachable !== undefined ? { reachable: endpoint.reachable } : {}),
+    modelRoute: serviceEndpointModelRoute(),
     ...(options.lookup ? { lookup: options.lookup } : {}),
     ...(options.includeParameters ? {
       policy: {
         effect: 'read-only',
         modelOperation: 'Inspect endpoint binding, network-facing posture, and optional reachability only.',
         lifecycle: 'GoodVibes Agent does not start, stop, restart, install, expose, or mutate connected-host listeners.',
-        settings: 'Use agent_harness settings/get_setting for read-only inspection of endpoint settings; connected-host lifecycle/listener settings stay locked in Agent.',
+        settings: 'Use agent_harness mode:"settings" or mode:"get_setting" for read-only inspection of endpoint settings; connected-host lifecycle/listener settings stay locked in Agent.',
       },
     } : {}),
   };
@@ -95,9 +96,14 @@ function describeEndpointCandidate(endpoint: CliServiceEndpointPosture): Record<
     label: endpoint.label,
     enabled: endpoint.enabled,
     binding: endpoint.binding,
+    modelRoute: serviceEndpointModelRoute(),
   };
 }
 
+function serviceEndpointModelRoute(): string {
+  return 'agent_harness mode:"service_endpoint" or mode:"settings"';
+}
+
 function endpointLookupFromArgs(args: AgentHarnessServicePostureArgs): { readonly source: ServiceEndpointLookupSource; readonly input: string } | null {
   const endpointId = readString(args.endpointId);
   if (endpointId) return { source: 'endpointId', input: endpointId };
@@ -182,6 +188,7 @@ export async function servicePostureSummary(
     ownership: 'external-connected-host',
     readOnly: true,
     lifecycle: 'GoodVibes Agent reports connected-host/service posture but does not start, stop, restart, install, expose, or mutate host listeners.',
+    modelRoute: serviceEndpointModelRoute(),
     config: posture.config,
     managed: posture.managed,
     endpoints: posture.endpoints.map((endpoint) => describeEndpoint(endpoint, { includeParameters: includeDetails })),
@@ -190,7 +197,7 @@ export async function servicePostureSummary(
     ...(includeDetails ? { modelAccess: {
       endpointLookup: 'Use mode:"service_endpoint" with endpointId, target, or query to inspect one endpoint.',
       settings: 'Use mode:"settings" with includeHidden:true for endpoint setting descriptors. Host-owned listener settings remain read-only.',
-      liveHostStatus: 'Use mode:"connected_host_status" for SDK compatibility, token posture, and Agent Knowledge route readiness.',
+      liveHostStatus: 'Use mode:"connected_host_status" for token posture and Agent Knowledge route readiness.',
     } } : {}),
   };
 }

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

@@ -1,4 +1,5 @@
 import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessSessionArgs {
   readonly sessionId?: unknown;
@@ -89,9 +90,18 @@ function describeSessionCandidate(session: SessionInfoLike, currentSessionId: st
     title: session.title || '(untitled)',
     messageCount: session.messageCount,
     active: session.name === currentSessionId,
+    modelRoute: sessionModelRoute(),
   };
 }
 
+function sessionModelRoute(): string {
+  return 'agent_harness mode:"session" or mode:"run_command"';
+}
+
+function bookmarkModelRoute(): string {
+  return 'agent_harness mode:"open_ui_surface" or agent_knowledge_ingest';
+}
+
 function describeSession(
   session: SessionInfoLike,
   options: {
@@ -110,6 +120,8 @@ function describeSession(
     model: session.model || null,
     provider: session.provider || null,
     active: session.name === options.currentSessionId,
+    modelRoute: sessionModelRoute(),
+    ...(options.includeParameters ? {} : { summary: previewHarnessText(session.title || session.name) }),
     ...(posture ? { returnContext: posture } : {}),
     ...(options.search ? {
       search: {
@@ -164,24 +176,28 @@ function currentSession(context: CommandContext): Record<string, unknown> {
   };
 }
 
-function bookmarkSummary(context: CommandContext): Record<string, unknown> {
+function bookmarkSummary(context: CommandContext, includeParameters = false): Record<string, unknown> {
   const manager = context.workspace.bookmarkManager;
   if (!manager) {
     return {
       status: 'unavailable',
       bookmarks: 0,
       savedFiles: 0,
+      modelRoute: bookmarkModelRoute(),
     };
   }
   return {
     status: 'available',
     bookmarks: manager.list().length,
     savedFiles: manager.listSavedFiles().length,
-    modelRoutes: {
-      visibleBookmarkPicker: 'agent_harness mode:"open_ui_surface" surfaceId:"bookmarks" confirm:true explicitUserRequest:"..."',
-      command: '/bookmarks',
-      importIntoKnowledge: 'agent_knowledge_ingest sourceKind:"bookmarks_file" confirm:true explicitUserRequest:"..."',
-    },
+    modelRoute: bookmarkModelRoute(),
+    ...(includeParameters ? {
+      modelRoutes: {
+        visibleBookmarkPicker: 'agent_harness mode:"open_ui_surface" surfaceId:"bookmarks" confirm:true explicitUserRequest:"..."',
+        command: '/bookmarks',
+        importIntoKnowledge: 'agent_knowledge_ingest sourceKind:"bookmarks_file" confirm:true explicitUserRequest:"..."',
+      },
+    } : {}),
   };
 }
 
@@ -206,7 +222,7 @@ export function sessionSummary(context: CommandContext, args: AgentHarnessSessio
       returned: 0,
       total: 0,
       current: currentSession(context),
-      bookmarks: bookmarkSummary(context),
+      bookmarks: bookmarkSummary(context, args.includeParameters === true),
       policy: 'Session runtime or session manager is unavailable in this Agent context.',
     };
   }
@@ -221,7 +237,7 @@ export function sessionSummary(context: CommandContext, args: AgentHarnessSessio
   return {
     status: 'available',
     current: currentSession(context),
-    bookmarks: bookmarkSummary(context),
+    bookmarks: bookmarkSummary(context, args.includeParameters === true),
     sessions: limited.map((session) => {
       const search = searchByName.get(session.name);
       return describeSession(session, {

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

@@ -3,6 +3,7 @@ import { collectOnboardingSnapshot, deriveStep1Capabilities, deriveStep1Capabili
 import type { CommandContext } from '../input/command-registry.ts';
 import { buildProviderAccountSnapshot } from '../panels/provider-account-snapshot.ts';
 import { requireLocalUserAuthManager, requirePlatform, requireProvider, requireSecretsManager, requireServiceRegistry, requireShellPaths, requireSubscriptionManager } from '../input/commands/runtime-services.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessSetupArgs {
   readonly setupItemId?: unknown;
@@ -175,36 +176,46 @@ function describeItem(
     setupItemId: item.id,
     label: item.label,
     selected: item.selected,
-    detail: item.detail,
-    signals: signalsForItem(item, snapshot),
+    modelRoute: setupItemModelRoute(),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    ...(options.includeParameters ? {
-      policy: {
-        effect: 'read-only',
-        values: 'Setup posture returns onboarding readiness, counts, safe setting keys, and route metadata only; secret values and raw provider tokens are never returned.',
-        mutation: 'Setup apply, provider auth, local behavior import/create, channel delivery, and starter profile changes stay visible workspace, settings, slash-command, or first-class tool flows.',
-      },
-      modelAccess: {
-        inspectSetup: 'agent_harness mode:"setup_posture"',
-        inspectSetupItem: 'agent_harness mode:"setup_item"',
-        openOnboarding: 'agent_harness mode:"open_ui_surface" surfaceId:"onboarding" confirm:true explicitUserRequest:"..."',
-        setupWorkspace: 'agent_harness mode:"workspace_action" target:"setup"',
-        settings: 'agent_harness modes settings/get_setting/set_setting/reset_setting',
-        providerRouting: 'agent_harness mode:"model_routing"',
-        providerAccounts: 'agent_harness mode:"provider_accounts"',
-        channels: 'agent_harness mode:"channels"',
-        media: 'agent_harness mode:"media_posture"',
-        security: 'agent_harness mode:"security_posture"',
-      },
-    } : {}),
+    ...(options.includeParameters
+      ? {
+        detail: item.detail,
+        signals: signalsForItem(item, snapshot),
+        policy: {
+          effect: 'read-only',
+          values: 'Setup posture returns onboarding readiness, counts, safe setting keys, and route metadata only; secret values and raw provider tokens are never returned.',
+          mutation: 'Setup apply, provider auth, local behavior import/create, channel delivery, and starter profile changes stay visible workspace, settings, slash-command, or first-class tool flows.',
+        },
+        modelAccess: {
+          inspectSetup: 'agent_harness mode:"setup_posture"',
+          inspectSetupItem: 'agent_harness mode:"setup_item"',
+          openOnboarding: 'agent_harness mode:"open_ui_surface" surfaceId:"onboarding" confirm:true explicitUserRequest:"..."',
+          setupWorkspace: 'agent_harness mode:"workspace_action" target:"setup"',
+          settings: 'agent_harness mode:"settings"; inspect or mutate with get_setting, set_setting, or reset_setting',
+          providerRouting: 'agent_harness mode:"model_routing"',
+          providerAccounts: 'agent_harness mode:"provider_accounts"',
+          channels: 'agent_harness mode:"channels"',
+          media: 'agent_harness mode:"media_posture"',
+          security: 'agent_harness mode:"security_posture"',
+        },
+      }
+      : {
+        summary: previewHarnessText(item.detail),
+      }),
   };
 }
 
+function setupItemModelRoute(): string {
+  return 'agent_harness mode:"setup_item" or mode:"open_ui_surface"';
+}
+
 function describeCandidate(item: OnboardingStep1CapabilityItem): Record<string, unknown> {
   return {
     setupItemId: item.id,
     label: item.label,
     selected: item.selected,
+    modelRoute: setupItemModelRoute(),
   };
 }
 

package/src/tools/agent-harness-text.ts

@@ -0,0 +1,6 @@
+export const HARNESS_PREVIEW_LIMIT = 56;
+
+export function previewHarnessText(value: string, maxLength = HARNESS_PREVIEW_LIMIT): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}

package/src/tools/agent-harness-tool-schema.ts

@@ -1,5 +1,5 @@
 export const AGENT_HARNESS_MODES = [
-  'summary', 'cli_commands', 'cli_command', 'panels', 'panel', 'open_panel',
+  'summary', 'modes', 'mode', 'cli_commands', 'cli_command', 'panels', 'panel', 'open_panel',
   'ui_surfaces', 'ui_surface', 'open_ui_surface',
   'shortcuts', 'keybindings', 'keybinding', 'run_keybinding', 'set_keybinding', 'reset_keybinding',
   'commands', 'command', 'run_command', 'channels', 'channel', 'notifications', 'notification_target',