@leviyuan/lodestar 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leviyuan/lodestar",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "publishConfig": {
     "access": "public"
   },

package/src/cards.ts

@@ -337,6 +337,11 @@ export function askUserQuestionElement(
   toolUseId: string,
   questions: AskQuestion[],
   status: '🤔' | '✅' | '❌' = '🤔',
+  /** When set, only this option is rendered as "picked" — every other
+   * option turns into plain text (no click target). Used after the
+   * user has answered so the panel freezes in a sensible terminal
+   * state instead of inviting another click. */
+  pickedOptionIdx?: number,
   resolvedNote?: string,
 ): object {
   const primary = questions[0]
@@ -345,18 +350,38 @@ export function askUserQuestionElement(
   const bodyElements: any[] = []
   if (primary) {
     bodyElements.push({ tag: 'markdown', content: `**${primary.question}**` })
-    // Stack option buttons in a column_set — one button per option.
-    // Each carries `kind:'ask'` + the toolUseId + question/option idx
-    // so the daemon's card action handler can map a click back to
-    // exactly one (question, choice) pair.
-    bodyElements.push({
-      tag: 'column_set',
-      columns: primary.options.map((opt, optIdx) => ({
-        tag: 'column', width: 'weighted', weight: 1,
-        elements: [{
-          tag: 'button',
-          text: { tag: 'plain_text', content: opt.label },
-          type: 'default',
+    // One row per option, each a full-width interactive_container so
+    // the entire row (label + description) is the click target. Looks
+    // cleaner than a row of squat buttons and matches the way IM
+    // quick-replies usually present themselves. After the user picks,
+    // we still render the same row layout (no JSON dump) but strip
+    // the callbacks — selected option marked ✅, others dimmed.
+    for (let optIdx = 0; optIdx < primary.options.length; optIdx++) {
+      const opt = primary.options[optIdx]
+      const isPicked = pickedOptionIdx === optIdx
+      const isAnswered = pickedOptionIdx !== undefined
+      const labelLine = isPicked
+        ? `**✅ ${opt.label}**`
+        : isAnswered
+          ? `~~${opt.label}~~`
+          : `**${opt.label}**`
+      const descLine = opt.description ? `\n${opt.description}` : ''
+      const rowContent = { tag: 'markdown', content: `${labelLine}${descLine}` }
+      if (isAnswered) {
+        // Frozen — no behaviors, plain container so it stops looking
+        // clickable.
+        bodyElements.push({
+          tag: 'div',
+          elements: [rowContent],
+        })
+      } else {
+        bodyElements.push({
+          tag: 'interactive_container',
+          background_style: 'default',
+          has_border: true,
+          corner_radius: '6px',
+          padding: '8px 12px',
+          margin: '4px 0',
           behaviors: [{
             type: 'callback',
             value: {
@@ -366,15 +391,10 @@ export function askUserQuestionElement(
               option_idx: optIdx,
             },
           }],
-        }],
-      })),
-    })
-    // Inline option descriptions below the buttons so the user can
-    // read context without hovering.
-    const descLines = primary.options
-      .map((o, idx) => o.description ? `- **${o.label}** — ${o.description}` : `- **${o.label}**`)
-      .join('\n')
-    if (descLines) bodyElements.push({ tag: 'markdown', content: descLines })
+          elements: [rowContent],
+        })
+      }
+    }
   }
   // Secondary questions get text-only treatment (TODO: multi-question
   // panels when actually requested by a real prompt).

package/src/session.ts

@@ -76,11 +76,20 @@ export class Session {
   private proc: ClaudeProcess | null = null
   private currentTurn: TurnState | null = null
   private pendingPermissions = new Map<string, { toolUseId: string }>()
-  /** Open AskUserQuestion tool calls — keyed by tool_use_id, valued
-   * with the questions array so we can construct the `answers` reply
-   * once a button is clicked. Cleared when the answer is sent or the
-   * turn ends. */
-  private pendingAsks = new Map<string, { questions: cards.AskQuestion[]; i: number }>()
+  /** Open AskUserQuestion tool calls — keyed by tool_use_id. The SDK
+   * routes AskUserQuestion through the can_use_tool flow even under
+   * bypass; we have to thread the permission `requestId` through here
+   * so onAskAnswer can answer it with `updatedInput.answers` populated.
+   * `deferredAnswer` covers the race where the user clicks a button
+   * BEFORE can_use_tool arrives (addTool fires on the assistant
+   * message; can_use_tool is a separate control_request that lands
+   * slightly later). */
+  private pendingAsks = new Map<string, {
+    questions: cards.AskQuestion[]
+    i: number
+    requestId?: string
+    deferredAnswer?: { questionIdx: number; optionIdx: number; user: string }
+  }>()
   private turnCounter = 0
   // Last seen sessionId — preserved across `kill`/`stop` so a later
   // `restart` can resume the same Claude conversation even after the
@@ -317,40 +326,70 @@ export class Session {
     }
   }
 
-  /** Handle a click on an AskUserQuestion option button. We construct
-   * the SDK-shaped `answers` map (question text → picked option label),
-   * send it back as a `tool_result`, and freeze the panel showing the
-   * picked option. The permission half of the flow was already auto-
-   * allowed in `renderPermission`, so no second action needed there. */
+  /** Click handler for an AskUserQuestion option button. The actual
+   * "send answer to Claude" plumbing lives in `resolveAsk` — this
+   * wrapper just chooses between answering immediately (the common
+   * case: can_use_tool has already arrived and parked a requestId on
+   * the pendingAsk record) versus deferring (the rare race where the
+   * user clicks before can_use_tool lands). */
   async onAskAnswer(toolUseId: string, questionIdx: number, optionIdx: number, user: string): Promise<void> {
     const pending = this.pendingAsks.get(toolUseId)
     if (!pending) { log(`session "${this.sessionName}": stray ask answer for ${toolUseId}`); return }
+    if (pending.requestId) {
+      this.resolveAsk(toolUseId, pending.requestId, questionIdx, optionIdx, user)
+    } else {
+      // can_use_tool hasn't landed yet — park the click. renderPermission
+      // will drain it the moment the request arrives.
+      pending.deferredAnswer = { questionIdx, optionIdx, user }
+      log(`session "${this.sessionName}": ask answer deferred for ${toolUseId} (no requestId yet)`)
+    }
+  }
+
+  /** Settle an AskUserQuestion: emit the permission allow with the
+   * picked option folded into `updatedInput.answers` (this is the
+   * shape the SDK reads to synthesise the tool_result string), repaint
+   * the panel ✅, drop bookkeeping. Single source of truth — both the
+   * normal click path and the deferred-answer drain go through here. */
+  private resolveAsk(
+    toolUseId: string,
+    requestId: string,
+    questionIdx: number,
+    optionIdx: number,
+    user: string,
+  ): void {
+    const pending = this.pendingAsks.get(toolUseId)
+    if (!pending) return
     const q = pending.questions[questionIdx]
     const opt = q?.options?.[optionIdx]
     if (!q || !opt) {
       log(`session "${this.sessionName}": ask answer out of range q=${questionIdx} o=${optionIdx}`)
       return
     }
-    // Build the answers map. SDK keys answers by the question text
-    // (matches what the AskUserQuestion contract expects). For
-    // unanswered secondary questions we don't include them — the SDK
-    // tolerates a partial map; Claude will see whichever it got.
+    const turn = this.currentTurn
+    const meta = turn?.toolByUseId.get(toolUseId)
+    const originalInput = meta?.input ?? {}
+    // SDK keys the answer record by the question's text — confirmed
+    // by the v0.1.2 jsonl trace (empty record formatted to "User has
+    // answered your questions: ."). Populate the key matching this
+    // question with the chosen option's label.
     const answers: Record<string, string> = { [q.question]: opt.label }
-    const content = JSON.stringify({ answers })
-    this.proc?.sendToolResult(toolUseId, content)
+    this.proc?.sendPermissionResponse(requestId, 'allow', {
+      updatedInput: { ...originalInput, answers },
+    })
+    this.pendingPermissions.delete(requestId)
     this.pendingAsks.delete(toolUseId)
 
-    // Repaint the panel to reflect the final choice — same element_id,
-    // status flips to ✅, body shows what was picked.
-    const turn = this.currentTurn
-    const meta = turn?.toolByUseId.get(toolUseId)
     if (turn && meta) {
-      meta.output = content
+      meta.output = JSON.stringify({ answers })
       meta.isError = false
-      const resolvedNote = `\n\n✅ **已回答** by ${user || '匿名'}: ${opt.label}`
-      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', resolvedNote)
+      const resolvedNote = `\n\n*已由 ${user || '匿名'} 回答*`
+      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', optionIdx, resolvedNote)
       void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
     }
+
+    if (this.pendingPermissions.size === 0 && this.status === 'awaiting_permission') {
+      this.status = 'working'
+    }
   }
 
   async onConsoleAction(action: string): Promise<void> {
@@ -567,6 +606,12 @@ export class Session {
     // can't discard the output after the first paint.
     meta.output = output
     meta.isError = isError
+    // AskUserQuestion already had its final panel painted by resolveAsk
+    // (✅ + the chosen option marked, others dimmed). The tool_result
+    // arriving here is just the SDK's synthesised echo — re-rendering
+    // via toolCallElement would clobber the nice option-row layout
+    // with a generic JSON dump. Bail out; the panel is done.
+    if (meta.name === 'AskUserQuestion') return
     // Update the local todo mirror BEFORE rendering so the just-
     // completed panel shows the new state too (e.g. a TaskCreate panel
     // already lists the task it just created).
@@ -680,17 +725,32 @@ export class Session {
       this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'unknown tool_use_id' })
       return
     }
-    // AskUserQuestion: daemon already rendered the choice UI in addTool
-    // and is collecting the user's answer asynchronously. The SDK
-    // wraps it in the standard permission flow anyway (even under
-    // bypassPermissions), so we auto-allow the request — otherwise
-    // Claude would block on can_use_tool forever, AND our permission
-    // renderer would overwrite the ask UI with the wrong 3-button
-    // panel. Keeping it allow-by-default also matches the user's
-    // mental model: they expect to choose an option, not "approve"
-    // the question itself.
+    // AskUserQuestion: SDK routes it through can_use_tool even under
+    // bypass. The PAYLOAD of "user has answered" is the permission
+    // response itself — specifically `updatedInput.answers`. So we
+    // CANNOT auto-allow here (that's the v0.1.2 bug: SDK got an empty
+    // answers map and immediately synthesised a "User has answered
+    // your questions: ." tool_result). Park the requestId on the
+    // pendingAsk record and wait for the user to click an option;
+    // onAskAnswer will then send allow + updatedInput.answers in one
+    // shot. If the user already clicked between addTool and now —
+    // the deferredAnswer slot — settle immediately.
     if (meta.name === 'AskUserQuestion') {
-      this.proc?.sendPermissionResponse(req.request_id, 'allow')
+      const ask = this.pendingAsks.get(toolUseId)
+      if (!ask) {
+        // Defensive: addTool should have populated pendingAsks. If it
+        // didn't, fall back to a denial so Claude doesn't hang.
+        log(`session "${this.sessionName}": AskUserQuestion ${toolUseId} missing pendingAsk — deny`)
+        this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no pending ask' })
+        return
+      }
+      ask.requestId = req.request_id
+      this.pendingPermissions.set(req.request_id, { toolUseId })
+      if (ask.deferredAnswer) {
+        const { questionIdx, optionIdx, user } = ask.deferredAnswer
+        ask.deferredAnswer = undefined
+        this.resolveAsk(toolUseId, req.request_id, questionIdx, optionIdx, user)
+      }
       return
     }
     this.status = 'awaiting_permission'