@plmbr/notebook-intelligence 5.0.1 → 5.1.0-a.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@plmbr/notebook-intelligence",
-    "version": "5.0.1",
+    "version": "5.1.0-a.1",
     "description": "AI coding assistant for JupyterLab",
     "keywords": [
         "AI",
@@ -49,6 +49,7 @@
         "install:extension": "jlpm build",
         "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
         "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+        "postinstall": "husky || exit 0",
         "prettier": "jlpm prettier:base --write --list-different",
         "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
         "prettier:check": "jlpm prettier:base --check",
@@ -98,8 +99,10 @@
         "eslint": "^8.36.0",
         "eslint-config-prettier": "^8.8.0",
         "eslint-plugin-prettier": "^5.0.0",
+        "husky": "^9.1.7",
         "jest": "^29.7.0",
         "jest-environment-jsdom": "^29.7.0",
+        "lint-staged": "^15.2.10",
         "mkdirp": "^1.0.3",
         "monaco-editor-webpack-plugin": "^2.0.0",
         "npm-run-all": "^4.1.5",
@@ -238,6 +241,9 @@
             }
         ]
     },
+    "lint-staged": {
+        "*": "prettier --write --ignore-unknown"
+    },
     "stylelint": {
         "extends": [
             "stylelint-config-recommended",

package/src/api.ts

@@ -388,6 +388,10 @@ export class NBIConfig {
     return this.capabilities.claude_settings;
   }
 
+  get spinnerVerbs(): { mode: string; verbs: string[] } | null {
+    return this.capabilities.spinner_verbs ?? null;
+  }
+
   get claudeModels(): IClaudeModelInfo[] {
     return (this.capabilities.claude_models ?? []).map(claudeModelFromWire);
   }
@@ -435,6 +439,10 @@ export class NBIConfig {
     return this.capabilities.chat_feedback_enabled === true;
   }
 
+  get chatFeedbackAlwaysVisible(): boolean {
+    return this.capabilities.chat_feedback_always_visible === true;
+  }
+
   // Admin-supplied tour-copy overrides, served from the capabilities
   // response after server-side validation. Returns the raw dict; the
   // tour module decides how to apply it. Defaults to a shared frozen

package/src/chat-sidebar.tsx

@@ -80,6 +80,8 @@ import { mcpServerSettingsToEnabledState } from './components/mcp-util';
 import claudeSvgStr from '../style/icons/claude.svg';
 import { AskUserQuestion } from './components/ask-user-question';
 import { ClaudeSessionPicker } from './components/claude-session-picker';
+import { ToolCallGroup } from './components/tool-call-group';
+import { upsertToolCallContent } from './tool-call-stream';
 import { TourOverlay } from './tour/tour-overlay';
 import { TOUR_ANCHOR } from './tour/tour-anchors';
 import { TOUR_START_EVENT, TOUR_STOP_EVENT } from './tour/tour-events';
@@ -522,6 +524,92 @@ function ChatResponseHTMLFrame(props: any) {
 // Memoize ChatResponse for performance
 function ChatResponse(props: any) {
   const [renderCount, setRenderCount] = useState(0);
+  const shuffledOrder = useRef<number[]>([]);
+  const shufflePos = useRef(0);
+
+  const _spinnerVerbs = NBIAPI.config.isInClaudeCodeMode
+    ? (NBIAPI.config.spinnerVerbs ?? null)
+    : null;
+  const hasCustomVerbs =
+    _spinnerVerbs?.mode === 'replace' &&
+    Array.isArray(_spinnerVerbs.verbs) &&
+    _spinnerVerbs.verbs.length > 0;
+
+  // Fisher-Yates shuffle. When `avoidFirst` is set, swap it out of
+  // position 0 so the new first verb is never the same as the last shown
+  // (prevents an identical repeat at the wrap point between passes).
+  const shuffleVerbs = (verbs: any[], avoidFirst?: number): number[] => {
+    const order = verbs.map((_, i) => i);
+    for (let i = order.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [order[i], order[j]] = [order[j], order[i]];
+    }
+    if (
+      avoidFirst !== undefined &&
+      order[0] === avoidFirst &&
+      order.length > 1
+    ) {
+      [order[0], order[1]] = [order[1], order[0]];
+    }
+    return order;
+  };
+
+  // Initialize the shuffle synchronously in useState so the correct verb
+  // is shown on the very first paint. A useEffect-based init fires after
+  // paint and causes a single-frame flash of verbs[0] before correcting.
+  const [verbIndex, setVerbIndex] = useState(() => {
+    const sv = NBIAPI.config.isInClaudeCodeMode
+      ? (NBIAPI.config.spinnerVerbs ?? null)
+      : null;
+    if (
+      !sv ||
+      sv.mode !== 'replace' ||
+      !Array.isArray(sv.verbs) ||
+      sv.verbs.length === 0
+    ) {
+      return 0;
+    }
+    const order = shuffleVerbs(sv.verbs);
+    shuffledOrder.current = order;
+    shufflePos.current = 0;
+    return order[0];
+  });
+
+  useEffect(() => {
+    if (!props.showGenerating || !hasCustomVerbs) {
+      return;
+    }
+
+    const verbs = _spinnerVerbs!.verbs;
+
+    // Shuffle already initialized by useState on mount. Only re-initialize
+    // if hasCustomVerbs just became true after a capabilities refresh
+    // (shuffledOrder would be empty because the lazy init found no verbs).
+    if (shuffledOrder.current.length === 0) {
+      shuffledOrder.current = shuffleVerbs(verbs);
+      shufflePos.current = 0;
+      setVerbIndex(shuffledOrder.current[0]);
+    }
+
+    let id: ReturnType<typeof setTimeout>;
+    const scheduleNext = () => {
+      const delay = 4000 + Math.random() * 3000;
+      id = setTimeout(() => {
+        shufflePos.current++;
+        if (shufflePos.current >= shuffledOrder.current.length) {
+          const lastShown =
+            shuffledOrder.current[shuffledOrder.current.length - 1];
+          shuffledOrder.current = shuffleVerbs(verbs, lastShown);
+          shufflePos.current = 0;
+        }
+        setVerbIndex(shuffledOrder.current[shufflePos.current]);
+        scheduleNext();
+      }, delay);
+    };
+    scheduleNext();
+    return () => clearTimeout(id);
+  }, [props.showGenerating, hasCustomVerbs]);
+
   const msg: IChatMessage = props.message;
   const timestamp = msg.date.toLocaleTimeString('en-US', { hour12: false });
 
@@ -630,6 +718,19 @@ function ChatResponse(props: any) {
       if (item.reasoningFinished) {
         lastItem.reasoningFinished = true;
       }
+    } else if (
+      item.type === ResponseStreamDataType.ToolCall &&
+      lastItemType === ResponseStreamDataType.ToolCall
+    ) {
+      // Bundle a run of consecutive tool calls into one group item so the
+      // renderer can collapse them; ToolCallGroup unwraps content.toolCalls.
+      const lastItem = groupedContents[groupedContents.length - 1];
+      lastItem.content.toolCalls.push(structuredClone(item.content));
+    } else if (item.type === ResponseStreamDataType.ToolCall) {
+      const grouped = structuredClone(item);
+      grouped.content = { toolCalls: [structuredClone(item.content)] };
+      groupedContents.push(grouped);
+      lastItemType = item.type;
     } else {
       groupedContents.push(structuredClone(item));
       lastItemType = item.type;
@@ -712,18 +813,26 @@ function ChatResponse(props: any) {
               }`}
               aria-hidden="true"
             />
-            <div
-              className="generating-label"
-              aria-live="polite"
-              aria-atomic="true"
-            >
+            <div className="generating-label" aria-hidden="true">
               {props.isStalled
                 ? 'Still working, server may be slow'
-                : 'Generating'}
+                : hasCustomVerbs
+                  ? _spinnerVerbs!.verbs[verbIndex]
+                  : 'Generating'}
               {props.showGenerating && props.elapsedSeconds > 0
                 ? ` (${formatElapsedSeconds(props.elapsedSeconds)})`
                 : ''}
             </div>
+            {/* aria-live region contains only the verb — no elapsed suffix —
+                so screen readers announce only on verb changes, not on every
+                elapsed-seconds tick. */}
+            <div className="nbi-sr-only" aria-live="polite" aria-atomic="true">
+              {props.isStalled
+                ? 'Still working, server may be slow'
+                : hasCustomVerbs
+                  ? _spinnerVerbs!.verbs[verbIndex]
+                  : 'Generating'}
+            </div>
           </div>
         </div>
         <div className="chat-message-timestamp">{timestamp}</div>
@@ -857,6 +966,17 @@ function ChatResponse(props: any) {
                   {item.content}
                 </div>
               ) : null;
+            case ResponseStreamDataType.ToolCall:
+              // Unlike Progress, tool-call cards persist after the turn ends,
+              // so they render regardless of `showGenerating`. The grouping
+              // pass bundled this run's calls into content.toolCalls; the
+              // group renders a single card or a collapsible group.
+              return (
+                <ToolCallGroup
+                  key={`key-${index}`}
+                  toolCalls={item.content.toolCalls}
+                />
+              );
             case ResponseStreamDataType.Confirmation:
               return answeredForms.get(item.id) ===
                 'confirmed' ? null : answeredForms.get(item.id) ===
@@ -973,9 +1093,13 @@ function ChatResponse(props: any) {
         )}
       </div>
       {msg.from === 'copilot' &&
-        !props.showGenerating &&
+        (NBIAPI.config.chatFeedbackAlwaysVisible || !props.showGenerating) &&
         NBIAPI.config.chatFeedbackEnabled && (
-          <div className="chat-message-feedback">
+          <div
+            className={`chat-message-feedback${
+              NBIAPI.config.chatFeedbackAlwaysVisible ? ' always-visible' : ''
+            }`}
+          >
             <button
               className={`chat-feedback-btn ${msg.feedback === 'positive' ? 'selected' : ''}`}
               onClick={() => {
@@ -994,9 +1118,9 @@ function ChatResponse(props: any) {
                   });
                 }
               }}
-              aria-label="Rate as helpful"
+              aria-label="Rate response as good"
               aria-pressed={msg.feedback === 'positive'}
-              title="Helpful"
+              title="Good response"
             >
               {msg.feedback === 'positive' ? (
                 <VscThumbsupFilled />
@@ -1022,9 +1146,9 @@ function ChatResponse(props: any) {
                   });
                 }
               }}
-              aria-label="Rate as unhelpful"
+              aria-label="Rate response as bad"
               aria-pressed={msg.feedback === 'negative'}
-              title="Not helpful"
+              title="Bad response"
             >
               {msg.feedback === 'negative' ? (
                 <VscThumbsdownFilled />
@@ -2920,22 +3044,33 @@ function SidebarComponent(props: any) {
             }
             if (delta['nbiContent']) {
               const nbiContent = delta['nbiContent'];
-              contents.push({
-                id: UUID.uuid4(),
-                type: nbiContent.type,
-                content: nbiContent.content || '',
-                reasoningContent: nbiContent.reasoning_content || '',
-                reasoningTag: nbiContent.reasoning_content
-                  ? '<think>'
-                  : undefined,
-                reasoningFinished:
-                  nbiContent.type === ResponseStreamDataType.Markdown &&
-                  nbiContent.reasoning_content
-                    ? true
-                    : false,
-                contentDetail: nbiContent.detail,
-                created: new Date(response.created)
-              });
+              if (nbiContent.type === ResponseStreamDataType.ToolCall) {
+                // A tool call streams twice under one id (start, then finish);
+                // merge by id so it stays one persistent card. See
+                // upsertToolCallContent.
+                upsertToolCallContent(
+                  contents,
+                  nbiContent.content,
+                  new Date(response.created)
+                );
+              } else {
+                contents.push({
+                  id: UUID.uuid4(),
+                  type: nbiContent.type,
+                  content: nbiContent.content || '',
+                  reasoningContent: nbiContent.reasoning_content || '',
+                  reasoningTag: nbiContent.reasoning_content
+                    ? '<think>'
+                    : undefined,
+                  reasoningFinished:
+                    nbiContent.type === ResponseStreamDataType.Markdown &&
+                    nbiContent.reasoning_content
+                      ? true
+                      : false,
+                  contentDetail: nbiContent.detail,
+                  created: new Date(response.created)
+                });
+              }
             } else {
               responseMessage =
                 response.data['choices']?.[0]?.['delta']?.['content'];
@@ -3356,22 +3491,33 @@ function SidebarComponent(props: any) {
 
             if (delta['nbiContent']) {
               const nbiContent = delta['nbiContent'];
-              contents.push({
-                id: UUID.uuid4(),
-                type: nbiContent.type,
-                content: nbiContent.content || '',
-                reasoningContent: nbiContent.reasoning_content || '',
-                reasoningTag: nbiContent.reasoning_content
-                  ? '<think>'
-                  : undefined,
-                reasoningFinished:
-                  nbiContent.type === ResponseStreamDataType.Markdown &&
-                  nbiContent.reasoning_content
-                    ? true
-                    : false,
-                contentDetail: nbiContent.detail,
-                created: new Date(response.created)
-              });
+              if (nbiContent.type === ResponseStreamDataType.ToolCall) {
+                // A tool call streams twice under one id (start, then finish);
+                // merge by id so it stays one persistent card. See
+                // upsertToolCallContent.
+                upsertToolCallContent(
+                  contents,
+                  nbiContent.content,
+                  new Date(response.created)
+                );
+              } else {
+                contents.push({
+                  id: UUID.uuid4(),
+                  type: nbiContent.type,
+                  content: nbiContent.content || '',
+                  reasoningContent: nbiContent.reasoning_content || '',
+                  reasoningTag: nbiContent.reasoning_content
+                    ? '<think>'
+                    : undefined,
+                  reasoningFinished:
+                    nbiContent.type === ResponseStreamDataType.Markdown &&
+                    nbiContent.reasoning_content
+                      ? true
+                      : false,
+                  contentDetail: nbiContent.detail,
+                  created: new Date(response.created)
+                });
+              }
             } else {
               const responseMessage =
                 response.data['choices']?.[0]?.['delta']?.['content'];

package/src/components/tool-call-card.tsx

@@ -0,0 +1,146 @@
+import React, { useState } from 'react';
+import {
+  VscChevronDown,
+  VscChevronRight,
+  VscClose,
+  VscEdit,
+  VscError,
+  VscEye,
+  VscPassFilled,
+  VscSync,
+  VscTerminal,
+  VscTools
+} from '../icons';
+
+export interface IToolCallDiffLine {
+  type: 'add' | 'remove' | 'context' | string;
+  content: string;
+}
+
+export interface IToolCallDiff {
+  path: string;
+  lines: IToolCallDiffLine[];
+  truncated?: boolean;
+}
+
+/**
+ * A single agent tool call surfaced as a persistent chat card. Mirrors the
+ * `ToolCallData` payload emitted by the server: it stays in the transcript
+ * after the turn ends and carries its final status, unlike the transient
+ * single progress line it replaces. File-edit tools also carry inline diffs.
+ */
+export interface IToolCall {
+  id: string;
+  title: string;
+  // Coarse category, used only to pick the leading icon.
+  kind: 'read' | 'edit' | 'execute' | 'other' | string;
+  status: 'in_progress' | 'completed' | 'failed' | 'cancelled' | string;
+  diffs?: IToolCallDiff[];
+}
+
+const KIND_ICONS: Record<string, React.FC<any>> = {
+  read: VscEye,
+  edit: VscEdit,
+  execute: VscTerminal,
+  other: VscTools
+};
+
+const STATUS_LABELS: Record<string, string> = {
+  in_progress: 'in progress',
+  completed: 'completed',
+  failed: 'failed',
+  cancelled: 'cancelled'
+};
+
+const GUTTER: Record<string, string> = { add: '+', remove: '-' };
+
+function ToolCallDiffView(props: { diffs: IToolCallDiff[] }): JSX.Element {
+  return (
+    <div className="nbi-tool-call-diffs">
+      {props.diffs.map((diff, i) => (
+        <div className="nbi-tool-call-diff" key={i}>
+          {diff.path ? (
+            <div className="nbi-tool-call-diff-path" title={diff.path}>
+              {diff.path}
+            </div>
+          ) : null}
+          <div className="nbi-tool-call-diff-body">
+            {diff.lines.map((line, j) => (
+              <div
+                className={`nbi-tool-call-diff-line nbi-diff-${line.type}`}
+                key={j}
+              >
+                <span className="nbi-diff-gutter" aria-hidden="true">
+                  {GUTTER[line.type] ?? ' '}
+                </span>
+                {/* The +/- gutter is decorative; give screen readers the
+                    add/remove distinction as text instead. */}
+                {line.type === 'add' || line.type === 'remove' ? (
+                  <span className="nbi-sr-only">
+                    {line.type === 'add' ? 'added ' : 'removed '}
+                  </span>
+                ) : null}
+                <span className="nbi-diff-text">{line.content}</span>
+              </div>
+            ))}
+          </div>
+          {diff.truncated ? (
+            <div className="nbi-tool-call-diff-truncated">diff truncated</div>
+          ) : null}
+        </div>
+      ))}
+    </div>
+  );
+}
+
+export function ToolCallCard(props: { toolCall: IToolCall }): JSX.Element {
+  const { title, kind, status, diffs } = props.toolCall;
+  const [expanded, setExpanded] = useState(true);
+
+  const KindIcon = KIND_ICONS[kind] ?? VscTools;
+
+  let StatusIcon = VscSync;
+  if (status === 'completed') {
+    StatusIcon = VscPassFilled;
+  } else if (status === 'failed') {
+    StatusIcon = VscError;
+  } else if (status === 'cancelled') {
+    StatusIcon = VscClose;
+  }
+
+  const statusLabel = STATUS_LABELS[status] ?? status;
+  const statusModifier = status.replace(/_/g, '-');
+  const hasDiffs = Array.isArray(diffs) && diffs.length > 0;
+
+  return (
+    <div className="nbi-tool-call-wrapper">
+      <div className={`nbi-tool-call nbi-tool-call-${statusModifier}`}>
+        <KindIcon className="nbi-tool-call-kind-icon" aria-hidden="true" />
+        <span className="nbi-tool-call-title" title={title}>
+          {title}
+        </span>
+        {hasDiffs ? (
+          <button
+            type="button"
+            className="nbi-tool-call-diff-toggle"
+            onClick={() => setExpanded(e => !e)}
+            aria-expanded={expanded}
+            aria-label={expanded ? 'Hide diff' : 'Show diff'}
+          >
+            {expanded ? (
+              <VscChevronDown aria-hidden="true" />
+            ) : (
+              <VscChevronRight aria-hidden="true" />
+            )}
+          </button>
+        ) : null}
+        <StatusIcon className="nbi-tool-call-status-icon" aria-hidden="true" />
+        {/* Status reaches screen readers as text; the icons are decorative.
+            The visible title is already in the accessibility tree, so this
+            span carries only the status to avoid announcing the title twice. */}
+        <span className="nbi-sr-only">{statusLabel}</span>
+      </div>
+      {hasDiffs && expanded ? <ToolCallDiffView diffs={diffs!} /> : null}
+    </div>
+  );
+}

package/src/components/tool-call-group.tsx

@@ -0,0 +1,65 @@
+import React, { useState } from 'react';
+import { VscChevronDown, VscChevronRight } from '../icons';
+import { IToolCall, ToolCallCard } from './tool-call-card';
+
+// Groups with more calls than this start collapsed so a tool-heavy turn (or a
+// reloaded transcript) doesn't flood the chat. A live turn mounts the group at
+// length 1, so it starts expanded and stays visible as calls stream in.
+const GROUP_COLLAPSE_THRESHOLD = 3;
+
+/**
+ * Renders a run of consecutive tool calls. A single call is shown as a bare
+ * card; multiple calls are wrapped in one collapsible group with a summary
+ * header, so consecutive agent activity reads as one unit instead of a wall
+ * of rows.
+ */
+export function ToolCallGroup(props: { toolCalls: IToolCall[] }): JSX.Element {
+  const { toolCalls } = props;
+  // Hooks must run unconditionally and in a stable order: the group's length
+  // grows as calls stream in, so call useState before any length branch.
+  // Start collapsed only for a large group whose calls are all settled --
+  // never hide a still-running or failed call (matters on transcript reload,
+  // where a group can mount already large).
+  const [expanded, setExpanded] = useState(
+    () =>
+      toolCalls.length <= GROUP_COLLAPSE_THRESHOLD ||
+      toolCalls.some(t => t.status === 'in_progress' || t.status === 'failed')
+  );
+
+  if (toolCalls.length <= 1) {
+    return toolCalls.length === 1 ? (
+      <ToolCallCard toolCall={toolCalls[0]} />
+    ) : (
+      <></>
+    );
+  }
+
+  const failed = toolCalls.filter(t => t.status === 'failed').length;
+  const summary =
+    `${toolCalls.length} tool calls` + (failed ? ` (${failed} failed)` : '');
+
+  return (
+    <div className="nbi-tool-call-group">
+      <button
+        type="button"
+        className="nbi-tool-call-group-header"
+        onClick={() => setExpanded(e => !e)}
+        aria-expanded={expanded}
+      >
+        {expanded ? (
+          <VscChevronDown aria-hidden="true" />
+        ) : (
+          <VscChevronRight aria-hidden="true" />
+        )}
+        <span className="nbi-tool-call-group-summary">{summary}</span>
+      </button>
+      {expanded ? (
+        <div className="nbi-tool-call-group-body">
+          {toolCalls.map(toolCall => (
+            <ToolCallCard key={toolCall.id} toolCall={toolCall} />
+          ))}
+        </div>
+      ) : null}
+    </div>
+  );
+}

package/src/icons.ts

@@ -41,6 +41,7 @@ export const VscClose = asIcon(Vsc.VscClose);
 export const VscCloudUpload = asIcon(Vsc.VscCloudUpload);
 export const VscCopy = asIcon(Vsc.VscCopy);
 export const VscEdit = asIcon(Vsc.VscEdit);
+export const VscError = asIcon(Vsc.VscError);
 export const VscEye = asIcon(Vsc.VscEye);
 export const VscEyeClosed = asIcon(Vsc.VscEyeClosed);
 export const VscFile = asIcon(Vsc.VscFile);
@@ -55,6 +56,8 @@ export const VscSend = asIcon(Vsc.VscSend);
 export const VscSettingsGear = asIcon(Vsc.VscSettingsGear);
 export const VscSparkle = asIcon(Vsc.VscSparkle);
 export const VscStopCircle = asIcon(Vsc.VscStopCircle);
+export const VscSync = asIcon(Vsc.VscSync);
+export const VscTerminal = asIcon(Vsc.VscTerminal);
 export const VscThumbsdown = asIcon(Vsc.VscThumbsdown);
 export const VscThumbsdownFilled = asIcon(Vsc.VscThumbsdownFilled);
 export const VscThumbsup = asIcon(Vsc.VscThumbsup);

package/src/index.ts

@@ -106,6 +106,7 @@ import {
   cellOutputHasError,
   chooseWorkspaceDirectory,
   compareSelections,
+  buildResumeCommand,
   extractLLMGeneratedCode,
   getSelectionInEditor,
   getTokenCount,
@@ -1403,10 +1404,9 @@ const plugin: JupyterFrontEndPlugin<INotebookIntelligence> = {
             return React.createElement(LauncherPicker, {
               onSessionSelected: (session: IClaudeSessionInfo) => {
                 dialog.close();
-                const cmd = session.cwd
-                  ? `cd ${session.cwd} && claude --resume ${session.session_id}`
-                  : `claude --resume ${session.session_id}`;
-                launchCliInTerminal(cmd);
+                launchCliInTerminal(
+                  buildResumeCommand(session.cwd ?? '', session.session_id)
+                );
               }
             });
           }
@@ -1734,7 +1734,7 @@ const plugin: JupyterFrontEndPlugin<INotebookIntelligence> = {
           source: args.source as string
         });
 
-        return true;
+        return { cellIndex: newCellIndex };
       }
     });
 
@@ -1755,7 +1755,7 @@ const plugin: JupyterFrontEndPlugin<INotebookIntelligence> = {
           source: args.source as string
         });
 
-        return true;
+        return { cellIndex: newCellIndex };
       }
     });
 

package/src/tokens.ts

@@ -48,6 +48,7 @@ export enum ResponseStreamDataType {
   Button = 'button',
   Anchor = 'anchor',
   Progress = 'progress',
+  ToolCall = 'tool-call',
   Confirmation = 'confirmation',
   AskUserQuestion = 'ask-user-question'
 }