@leviyuan/lodestar 0.2.9 → 0.3.0

package/src/paths.ts

@@ -1,57 +0,0 @@
-/**
- * Filesystem layout — XDG Base Directory spec, with env-var overrides.
- *
- *   Config:   $LODESTAR_CONFIG_DIR | $XDG_CONFIG_HOME/lodestar | ~/.config/lodestar
- *   Data:     $LODESTAR_DATA_DIR   | $XDG_DATA_HOME/lodestar   | ~/.local/share/lodestar
- *
- *   config.toml             — credentials + preferences (in CONFIG_DIR)
- *   daemon.pid              — single-instance lock          (in DATA_DIR)
- *   daemon.log              — append-only run log           (in DATA_DIR)
- *   session-chat-map.json   — duplicate-name routing        (in DATA_DIR)
- *   session-resume-map.json — last-known claude session_id  (in DATA_DIR)
- *   inbox/                  — downloaded attachments        (in DATA_DIR)
- */
-
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-const HOME = homedir()
-
-function pickDir(envOverride: string | undefined, xdgVar: string | undefined, fallback: string): string {
-  if (envOverride) return envOverride
-  if (xdgVar) return join(xdgVar, 'lodestar')
-  return fallback
-}
-
-export const CONFIG_DIR = pickDir(
-  process.env.LODESTAR_CONFIG_DIR,
-  process.env.XDG_CONFIG_HOME,
-  join(HOME, '.config', 'lodestar'),
-)
-
-export const DATA_DIR = pickDir(
-  process.env.LODESTAR_DATA_DIR,
-  process.env.XDG_DATA_HOME,
-  join(HOME, '.local', 'share', 'lodestar'),
-)
-
-export const CONFIG_FILE = process.env.LODESTAR_CONFIG ?? join(CONFIG_DIR, 'config.toml')
-export const PID_FILE = join(DATA_DIR, 'daemon.pid')
-export const LOG_FILE = join(DATA_DIR, 'daemon.log')
-export const SESSION_CHAT_MAP_FILE = join(DATA_DIR, 'session-chat-map.json')
-export const SESSION_RESUME_MAP_FILE = join(DATA_DIR, 'session-resume-map.json')
-/** Marker file written at shutdown listing the session names that
- * were still alive. The next daemon boot reads it (and unlinks it)
- * to auto-revive those sessions via `restart(true)` — bridges the
- * gap between systemctl-restart killing every child Claude and
- * Lodestar's "you have to send a message to re-spawn it" default. */
-export const ALIVE_MARKER_FILE = join(DATA_DIR, 'alive-on-shutdown.json')
-export const INBOX_DIR = join(DATA_DIR, 'inbox')
-/** Unix-socket endpoint the daemon listens on for debug message
- * injection (see scripts/test-inject.ts). A real Feishu user sends
- * a `[DEBUG]…` text once to seed `DEBUG_CTX_FILE` with chat_id +
- * sender_open_id; the injector then POSTs `{text}` here and the
- * daemon replays it through `handleMessage` as if WS had delivered
- * it. File mode 0600 — daemon-private, never network-exposed. */
-export const DEBUG_SOCK_FILE = join(DATA_DIR, 'debug.sock')
-export const DEBUG_CTX_FILE = join(DATA_DIR, 'debug-context.json')

package/src/session-ask.ts

@@ -1,165 +0,0 @@
-/**
- * AskUserQuestion flow split out of session.ts. The SDK routes
- * AskUserQuestion through can_use_tool even under bypass mode, so the
- * "answered" state lives across two SDK control messages — option
- * clicks/custom text land via Feishu callbacks first, then
- * can_use_tool arrives and we finalize with `updatedInput.answers`.
- */
-
-import type { Session } from './session'
-import * as cardkit from './cardkit'
-import * as cards from './cards'
-import { log } from './log'
-
-/** True iff there's at least one open AskUserQuestion awaiting an
- * answer in this session. `daemon.handleMessage` uses this to
- * decide whether an inbound chat message should be a custom answer
- * (routed to onAskMessageAnswer) instead of opening a new turn. */
-export function hasPendingAsk(s: Session): boolean {
-  return s.pendingAsks.size > 0
-}
-
-/** Funnel an arbitrary chat message into the *current* question
- * of the oldest pending ask as a `customText` answer. Multi-
- * question semantics: from the user's perspective, the chat
- * input always answers whatever question is on screen right now
- * (`pending.currentIdx`), and a new question slides in after. */
-export async function onAskMessageAnswer(s: Session, text: string, user: string): Promise<void> {
-  const firstEntry = s.pendingAsks.entries().next()
-  if (firstEntry.done) {
-    log(`session "${s.sessionName}": onAskMessageAnswer with no pending — falling back to onUserMessage`)
-    await s.onUserMessage(text)
-    return
-  }
-  const [toolUseId, pending] = firstEntry.value
-  if (pending.currentIdx === undefined) {
-    log(`session "${s.sessionName}": pending ask ${toolUseId} already terminal — ignoring message`)
-    return
-  }
-  await onAskCustomAnswer(s, toolUseId, pending.currentIdx, text, user)
-}
-
-/** Click handler for an option button. The click must target the
- * question currently on screen (`pending.currentIdx`); a stale
- * click (e.g. user clicked an older render before it swapped in
- * the next question) is logged and dropped — better than double-
- * answering. */
-export async function onAskAnswer(
-  s: Session,
-  toolUseId: string,
-  questionIdx: number,
-  optionIdx: number,
-  user: string,
-): Promise<void> {
-  const pending = s.pendingAsks.get(toolUseId)
-  if (!pending) { log(`session "${s.sessionName}": stray ask answer for ${toolUseId}`); return }
-  if (questionIdx !== pending.currentIdx) {
-    log(`session "${s.sessionName}": stale ask click q=${questionIdx} current=${pending.currentIdx}`)
-    return
-  }
-  advanceAsk(s, toolUseId, { optionIdx, user })
-}
-
-/** Custom-text branch. Same staleness rule as onAskAnswer; empty
- * input is silently ignored (panel stays pending). */
-export async function onAskCustomAnswer(
-  s: Session,
-  toolUseId: string,
-  questionIdx: number,
-  customText: string,
-  user: string,
-): Promise<void> {
-  const pending = s.pendingAsks.get(toolUseId)
-  if (!pending) { log(`session "${s.sessionName}": stray ask custom for ${toolUseId}`); return }
-  const trimmed = (customText ?? '').trim()
-  if (!trimmed) { log(`session "${s.sessionName}": empty custom answer, ignoring`); return }
-  if (questionIdx !== pending.currentIdx) {
-    log(`session "${s.sessionName}": stale ask custom q=${questionIdx} current=${pending.currentIdx}`)
-    return
-  }
-  advanceAsk(s, toolUseId, { customText: trimmed, user })
-}
-
-/** Record an answer for the current question, advance the state
- * machine, repaint. If every question is now answered, finalize
- * (or defer the finalize until can_use_tool lands — the race is
- * handled by renderPermission). */
-export function advanceAsk(
-  s: Session,
-  toolUseId: string,
-  answer: { optionIdx?: number; customText?: string; user: string },
-): void {
-  const pending = s.pendingAsks.get(toolUseId)
-  if (!pending || pending.currentIdx === undefined) return
-  const cur = pending.currentIdx
-  const q = pending.questions[cur]
-  if (!q) { log(`session "${s.sessionName}": advanceAsk currentIdx=${cur} out of range`); return }
-  // Resolve the literal answer value — custom text wins if both set.
-  let value: string
-  if (answer.customText !== undefined) {
-    value = answer.customText
-  } else if (answer.optionIdx !== undefined) {
-    const opt = q.options?.[answer.optionIdx]
-    if (!opt) { log(`session "${s.sessionName}": advanceAsk option ${answer.optionIdx} out of range`); return }
-    value = opt.label
-  } else {
-    log(`session "${s.sessionName}": advanceAsk with neither customText nor optionIdx`)
-    return
-  }
-  pending.answers[q.question] = value
-  pending.answered.set(cur, {
-    optionIdx: answer.optionIdx,
-    customText: answer.customText,
-    user: answer.user,
-  })
-  // Next unanswered idx — linear from cur+1. Implementation
-  // always moves forward; we don't currently let users revisit a
-  // previous question (would need richer UI affordance for that).
-  const total = pending.questions.length
-  let nextIdx: number | undefined = undefined
-  for (let i = cur + 1; i < total; i++) {
-    if (!pending.answered.has(i)) { nextIdx = i; break }
-  }
-  pending.currentIdx = nextIdx
-
-  const turn = s.currentTurn
-  const meta = turn?.toolByUseId.get(toolUseId)
-  if (turn && meta) {
-    const el = cards.askUserQuestionElement(
-      meta.i, toolUseId, pending.questions,
-      nextIdx === undefined ? '✅' : '🤔',
-      { currentIdx: nextIdx, answered: pending.answered },
-    )
-    void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
-  }
-
-  if (nextIdx === undefined) {
-    // All done. Finalize iff we have the permission request id;
-    // otherwise renderPermission will pick it up when it arrives.
-    if (pending.requestId) finalizeAsk(s, toolUseId)
-    else log(`session "${s.sessionName}": ask ${toolUseId} all answered, waiting for can_use_tool`)
-  }
-}
-
-/** Settle a fully-answered AskUserQuestion: emit the SDK allow
- * with the full `answers` record folded into `updatedInput`,
- * drop bookkeeping, restore status. The terminal panel paint was
- * already done by the final advanceAsk; this is just protocol. */
-export function finalizeAsk(s: Session, toolUseId: string): void {
-  const pending = s.pendingAsks.get(toolUseId)
-  if (!pending || !pending.requestId) return
-  const meta = s.currentTurn?.toolByUseId.get(toolUseId)
-  const originalInput = meta?.input ?? {}
-  s.proc?.sendPermissionResponse(pending.requestId, 'allow', {
-    updatedInput: { ...originalInput, answers: pending.answers },
-  })
-  s.pendingPermissions.delete(pending.requestId)
-  if (meta) {
-    meta.output = JSON.stringify({ answers: pending.answers })
-    meta.isError = false
-  }
-  s.pendingAsks.delete(toolUseId)
-  if (s.pendingPermissions.size === 0 && s.status === 'awaiting_permission') {
-    s.status = 'working'
-  }
-}

package/src/session-permission.ts

@@ -1,136 +0,0 @@
-/**
- * Permission flow split out of session.ts. The daemon merges the
- * permission ask into the existing tool element in the current turn
- * card — one continuous timeline: ⏳ pending → 🔐 awaiting approval
- * (with buttons) → ⏳ allowed / ❌ denied → ✅ with output. No
- * floating orange card.
- */
-
-import type { Session } from './session'
-import type { CanUseToolRequest } from './claude-process'
-import * as cardkit from './cardkit'
-import * as cards from './cards'
-import * as feishu from './feishu'
-import { log } from './log'
-import { isTaskWorkflow, todosArray } from './session-tools'
-import { finalizeAsk } from './session-ask'
-
-export async function onPermissionDecision(
-  s: Session,
-  requestId: string,
-  decision: 'allow' | 'allow_always' | 'deny',
-  user: string,
-): Promise<void> {
-  const pending = s.pendingPermissions.get(requestId)
-  if (!pending) { log(`session "${s.sessionName}": stray permission ${requestId}`); return }
-  s.pendingPermissions.delete(requestId)
-
-  // Update the tool element in the main turn card in place — the
-  // permission decision lives on the same row as the tool call.
-  const turn = s.currentTurn
-  const meta = turn?.toolByUseId.get(pending.toolUseId)
-  if (turn && meta) {
-    const todos = isTaskWorkflow(meta.name) ? todosArray(s) : undefined
-    if (decision === 'deny') {
-      const el = cards.toolCallElement(meta.i, meta.name, meta.input, `🚫 已拒绝 by ${user || '匿名'}`, '❌', undefined, todos)
-      void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
-    } else {
-      const label = decision === 'allow_always' ? '始终允许' : '已允许'
-      meta.resolvedNote = `✅ **${label}** by ${user || '匿名'}`
-      const el = cards.toolCallElement(meta.i, meta.name, meta.input, null, '⏳', meta.resolvedNote, todos)
-      void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
-    }
-  }
-
-  const claudeDecision = decision === 'deny' ? 'deny' : 'allow'
-  s.proc?.sendPermissionResponse(requestId, claudeDecision)
-
-  if (decision === 'allow_always') {
-    s.proc?.sendSetPermissionMode('acceptEdits')
-  }
-
-  if (s.pendingPermissions.size === 0 && s.status === 'awaiting_permission') {
-    s.status = 'working'
-  }
-}
-
-/** Merge the permission ask into the existing tool element in the
- * current turn card. The user sees one continuous timeline: ⏳ pending
- * → 🔐 awaiting approval (with buttons) → ⏳ allowed / ❌ denied → ✅
- * with output. No floating orange card.
- *
- * `tool_use` is emitted as part of the assistant message and lands on
- * our `addTool` handler BEFORE the SDK's `can_use_tool` control_request
- * arrives — so by the time we get here, `toolByUseId` already has the
- * entry we need to replace.
- *
- * Edge cases (no current turn / missing tool_use_id / unknown id) are
- * surfaced loudly and auto-denied. We don't fall back to a standalone
- * card — per the project's no-fallbacks rule, hidden anomalies are
- * worse than visible deny errors. */
-export function renderPermission(s: Session, req: CanUseToolRequest): void {
-  const turn = s.currentTurn
-  if (!turn) {
-    log(`session "${s.sessionName}": can_use_tool with no current turn — auto-deny req=${req.request_id}`)
-    s.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no active turn' })
-    return
-  }
-  const toolUseId = req.tool_use_id
-  if (!toolUseId) {
-    log(`session "${s.sessionName}": can_use_tool without tool_use_id — auto-deny req=${req.request_id}`)
-    s.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no tool_use_id' })
-    return
-  }
-  const meta = turn.toolByUseId.get(toolUseId)
-  if (!meta) {
-    log(`session "${s.sessionName}": can_use_tool for unknown tool_use_id=${toolUseId} — auto-deny req=${req.request_id}`)
-    s.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'unknown tool_use_id' })
-    return
-  }
-  // 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') {
-    const ask = s.pendingAsks.get(toolUseId)
-    if (!ask) {
-      log(`session "${s.sessionName}": AskUserQuestion ${toolUseId} missing pendingAsk — deny`)
-      s.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no pending ask' })
-      return
-    }
-    ask.requestId = req.request_id
-    s.pendingPermissions.set(req.request_id, { toolUseId })
-    // Fast-clicker race: the user may have answered every question
-    // while we were still waiting for can_use_tool to arrive. If so,
-    // advanceAsk parked the all-done state and we drain it now.
-    if (ask.currentIdx === undefined) finalizeAsk(s, toolUseId)
-    return
-  }
-  s.status = 'awaiting_permission'
-  s.pendingPermissions.set(req.request_id, { toolUseId })
-  const el = cards.toolCallPermissionElement(meta.i, meta.name, meta.input, req.request_id)
-  void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
-  // Phone push — Claude is blocked until the user approves/denies.
-  // Set summary to "🔐 等审批: <tool>(<input summary>)" so the lock-
-  // screen notification shows which tool needs approval.
-  if (turn.userOpenId && turn.messageId) {
-    const inputSummary = cards.summarizeToolInput(meta.name, meta.input)
-    const tail = inputSummary && inputSummary.length > 30
-      ? inputSummary.slice(0, 30) + '…'
-      : inputSummary
-    const summary = tail
-      ? `🔐 等审批: ${meta.name} · ${tail}`
-      : `🔐 等审批: ${meta.name}`
-    void (async () => {
-      cardkit.cancelSummary(turn.cardId)
-      await cardkit.patchSettings(turn.cardId, { config: { summary: { content: summary } } })
-      await feishu.urgentApp(turn.messageId, [turn.userOpenId])
-    })()
-  }
-}

package/src/session-tools.ts

@@ -1,233 +0,0 @@
-/**
- * Tool-tracking helpers split out of session.ts. Free functions taking
- * a Session; fields they touch are package-internal (no `private`
- * modifier on the class side). Cross-file boundary lets the main
- * session.ts stay under Claude Code's per-read token budget.
- */
-
-import type { Session } from './session'
-import * as cardkit from './cardkit'
-import * as cards from './cards'
-import * as feishu from './feishu'
-
-export function isTaskWorkflow(name: string): boolean {
-  return name.startsWith('Task') && name !== 'Task'
-}
-
-export function todosArray(s: Session): cards.Todo[] {
-  return [...s.currentTodos.values()]
-}
-
-export function addTool(s: Session, toolUseId: string, name: string, input: any): void {
-  if (!s.currentTurn) return
-  // Close current assistant segment (if any) so the tool panel renders
-  // AFTER it in card body order. Flush queues the segment's last
-  // buffered delta before the tool element is inserted.
-  if (s.currentTurn.currentAssistantSegmentId) {
-    void cardkit.flush(s.currentTurn.cardId)
-    s.currentTurn.currentAssistantSegmentId = null
-    s.currentTurn.currentAssistantText = ''
-  }
-  // Consecutive Read merger: if a Read run is already open, append to
-  // its batch and re-render the panel instead of inserting a new one.
-  // Any other tool name closes the run (handled below).
-  if (name === 'Read' && s.currentTurn.openReadBatchI !== null) {
-    const batchI = s.currentTurn.openReadBatchI
-    const batch = s.currentTurn.readBatches.get(batchI)!
-    const slot = batch.items.length
-    batch.items.push({ toolUseId, input, output: null, isError: false })
-    s.currentTurn.toolByUseId.set(toolUseId, { i: batchI, name, input, readBatchSlot: slot })
-    const el = cards.readBatchElement(batchI, batch.items)
-    void cardkit.replaceElement(s.currentTurn.cardId, cards.ELEMENTS.tool(batchI), el)
-    return
-  }
-  if (name !== 'Read') s.currentTurn.openReadBatchI = null
-  const i = s.currentTurn.toolCount++
-  if (name === 'Read') {
-    // First Read of a potential run — render the existing single-tool
-    // panel (which keeps the full file-contents dump on completion). If
-    // a second Read arrives, completeTool/addTool will switch it to
-    // `readBatchElement`.
-    s.currentTurn.openReadBatchI = i
-    s.currentTurn.readBatches.set(i, {
-      items: [{ toolUseId, input, output: null, isError: false }],
-    })
-    s.currentTurn.toolByUseId.set(toolUseId, { i, name, input, readBatchSlot: 0 })
-    const el = cards.toolCallElement(i, name, input, null, '⏳', undefined, undefined)
-    void cardkit.addElement(s.currentTurn.cardId, el, {
-      type: 'insert_before', targetElementId: cards.ELEMENTS.footer,
-    })
-    return
-  }
-  s.currentTurn.toolByUseId.set(toolUseId, { i, name, input })
-  // AskUserQuestion is a client-side tool — daemon renders the choice
-  // UI in-line and supplies the tool_result itself once the user
-  // clicks. Branch BEFORE the generic toolCallElement so we never
-  // fall through to a JSON dump or, worse, get clobbered by the
-  // permission flow (which would render 🔐 three-button buttons that
-  // don't match the actual N options).
-  if (name === 'AskUserQuestion') {
-    const questions = Array.isArray(input?.questions) ? input.questions as cards.AskQuestion[] : []
-    const startIdx = questions.length > 0 ? 0 : undefined
-    const answered = new Map<number, cards.AskAnswered>()
-    s.pendingAsks.set(toolUseId, {
-      questions,
-      i,
-      answers: {},
-      answered,
-      currentIdx: startIdx,
-    })
-    const el = cards.askUserQuestionElement(i, toolUseId, questions, '🤔', {
-      currentIdx: startIdx,
-      answered,
-    })
-    void cardkit.addElement(s.currentTurn.cardId, el, {
-      type: 'insert_before',
-      targetElementId: cards.ELEMENTS.footer,
-    })
-    // Phone push — user has to come back and answer before Claude can
-    // continue. Set summary to the question text so the lock-screen
-    // notification preview shows what the user needs to answer.
-    if (s.currentTurn.userOpenId && s.currentTurn.messageId) {
-      const turn = s.currentTurn
-      const q0 = questions[0]?.question?.trim() ?? ''
-      const truncated = q0.length > 40 ? q0.slice(0, 40) + '…' : q0
-      const summary = questions.length > 1
-        ? `❓ 待回答 ${questions.length} 题${truncated ? `: ${truncated}` : ''}`
-        : truncated
-          ? `❓ ${truncated}`
-          : '❓ 等你回答问题'
-      void (async () => {
-        cardkit.cancelSummary(turn.cardId)
-        await cardkit.patchSettings(turn.cardId, { config: { summary: { content: summary } } })
-        await feishu.urgentApp(turn.messageId, [turn.userOpenId])
-      })()
-    }
-    return
-  }
-  // Pending Task* panels still show the *pre-op* todo mirror so users
-  // can read the current state immediately, without waiting for the
-  // tool to return.
-  const todos = isTaskWorkflow(name) ? todosArray(s) : undefined
-  const el = cards.toolCallElement(i, name, input, null, '⏳', undefined, todos)
-  void cardkit.addElement(s.currentTurn.cardId, el, {
-    type: 'insert_before',
-    targetElementId: cards.ELEMENTS.footer,
-  })
-}
-
-export function completeTool(s: Session, toolUseId: string, content: any, isError: boolean): void {
-  if (!s.currentTurn) return
-  const meta = s.currentTurn.toolByUseId.get(toolUseId)
-  if (!meta) return
-  const output = typeof content === 'string'
-    ? content
-    : Array.isArray(content)
-      ? content.map((c: any) => c?.text ?? JSON.stringify(c)).join('\n')
-      : JSON.stringify(content)
-  // Stash on the meta — every Task* op coming after this point may
-  // need to re-render this panel with a fresher todo footer, so we
-  // 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
-  // Read batch path: update this row's status in the shared batch then
-  // re-render. Single-item batches keep the original full-output panel
-  // (file-contents dump); 2+ items switch to the compact `Read · N 次`
-  // listing, which overwrites whatever was last drawn at this i.
-  if (meta.name === 'Read' && meta.readBatchSlot != null) {
-    const batch = s.currentTurn.readBatches.get(meta.i)
-    if (batch) {
-      const row = batch.items[meta.readBatchSlot]
-      if (row) { row.output = output; row.isError = isError }
-      const el = batch.items.length >= 2
-        ? cards.readBatchElement(meta.i, batch.items)
-        : cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote, undefined)
-      void cardkit.replaceElement(s.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
-    }
-    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).
-  if (!isError && isTaskWorkflow(meta.name)) {
-    updateTodosFromTask(s, meta.name, meta.input, output)
-  }
-  const todos = isTaskWorkflow(meta.name) ? todosArray(s) : undefined
-  const el = cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote, todos)
-  void cardkit.replaceElement(s.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
-  // Cascade the new mirror into every prior Task* panel in this turn
-  // so any expanded panel reflects the latest state, not the snapshot
-  // captured when that op ran.
-  if (!isError && isTaskWorkflow(meta.name)) {
-    refreshOtherTaskPanels(s, toolUseId)
-  }
-}
-
-/** Roll a single Task* op into the local mirror — best-effort. Output
- * parsing is regex-based (the SDK returns plain text like "Task #7
- * created successfully: …"), so unexpected variants are skipped
- * silently rather than blowing up the panel render. */
-export function updateTodosFromTask(s: Session, name: string, input: any, output: string): void {
-  switch (name) {
-    case 'TaskCreate': {
-      const m = output.match(/Task #(\d+) created/)
-      if (!m) return
-      const id = Number(m[1])
-      s.currentTodos.set(id, {
-        id,
-        subject: input.subject,
-        description: input.description,
-        activeForm: input.activeForm,
-        status: 'pending',
-      })
-      return
-    }
-    case 'TaskUpdate': {
-      const id = Number(input.taskId)
-      if (!Number.isFinite(id)) return
-      // status=deleted is the SDK's tombstone — drop from the mirror
-      // so the readout doesn't carry it forever. Server still keeps
-      // it; the mirror is just for the panel footer.
-      if (input.status === 'deleted') { s.currentTodos.delete(id); return }
-      const cur = s.currentTodos.get(id) ?? { id, status: 'pending' as const }
-      if (input.status)      cur.status = input.status
-      if (input.subject)     cur.subject = input.subject
-      if (input.description) cur.description = input.description
-      if (input.owner)       cur.owner = input.owner
-      if (input.activeForm)  cur.activeForm = input.activeForm
-      s.currentTodos.set(id, cur)
-      return
-    }
-    // TaskList / TaskGet / TaskStop / TaskOutput / TaskDelete:
-    // read-only or parse-heavy — skip mirror update. The panel will
-    // still render the SDK's textual result below the operation
-    // block, which is enough to disambiguate.
-  }
-}
-
-/** Re-render every Task* panel in the current turn (except the one
- * that just landed — already up-to-date) so they all show the latest
- * todo mirror in their footers. Cheap: ELEMENTS.tool(i) replace is
- * queued through the per-card Promise chain like any other op. */
-export function refreshOtherTaskPanels(s: Session, skipToolUseId: string): void {
-  if (!s.currentTurn) return
-  const todos = todosArray(s)
-  for (const [id, meta] of s.currentTurn.toolByUseId) {
-    if (id === skipToolUseId) continue
-    if (!isTaskWorkflow(meta.name)) continue
-    const status: '⏳' | '✅' | '❌' = meta.output === undefined
-      ? '⏳'
-      : (meta.isError ? '❌' : '✅')
-    const el = cards.toolCallElement(
-      meta.i, meta.name, meta.input, meta.output ?? null,
-      status, meta.resolvedNote, todos,
-    )
-    void cardkit.replaceElement(s.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
-  }
-}

package/src/session-types.ts

@@ -1,91 +0,0 @@
-/**
- * Shared types split out of session.ts so the main file stays under
- * Claude Code's per-read token budget (~25K). Pure type-only — no
- * runtime imports here. Companion modules: session-tools.ts,
- * session-ask.ts, session-permission.ts.
- */
-
-export interface TurnState {
-  cardId: string
-  /** Feishu message_id of the card — needed for urgent_app push on clean
-   * turn close. Kept separate from cardId because cardkit's stream APIs
-   * operate on card_id but the urgent_app endpoint takes message_id. */
-  messageId: string
-  /** open_id of the user who started this turn. Used to scope the
-   * urgent_app push so only the initiator gets pinged (in case there
-   * are other members in the group). Empty string → skip the ping. */
-  userOpenId: string
-  /** What kicked off this turn. Only `'user_message'` turns fire the
-   * end-of-turn urgent_app push — scheduled / cron / loop wakeups
-   * finish on their own time and pinging the user would be noise,
-   * not signal. Ask / permission urgents inside the turn still fire
-   * regardless (those genuinely need attention even mid-schedule). */
-  trigger: 'user_message' | 'scheduled'
-  thinkingText: string
-  toolCount: number
-  /** `output` / `isError` are filled in by completeTool — kept on the
-   * meta (instead of being thrown away after the first render) so a
-   * later Task* op can re-render every prior Task* panel with the
-   * latest todo mirror appended. */
-  toolByUseId: Map<string, {
-    i: number
-    name: string
-    input: any
-    resolvedNote?: string
-    output?: string
-    isError?: boolean
-    /** Set when this tool is part of a merged Read batch — points to the
-     * batch's slot in `readBatches[i].items`. completeTool uses it to
-     * update the right row instead of rendering a standalone panel. */
-    readBatchSlot?: number
-  }>
-  /** Consecutive `Read` calls collapse into a single panel rendered by
-   * `cards.readBatchElement`. Keyed by element index `i` so completeTool
-   * can find the batch after its open-window closed (a non-Read tool or
-   * new assistant segment has since arrived).
-   *
-   * `openReadBatchI` is the i of the batch currently accepting new Reads;
-   * null once the run ends. Subsequent Read calls open a fresh batch at a
-   * new i. */
-  readBatches: Map<number, {
-    items: Array<{ toolUseId: string; input: any; output: string | null; isError: boolean }>
-  }>
-  openReadBatchI: number | null
-  assistantSegmentCount: number
-  currentAssistantSegmentId: string | null
-  currentAssistantText: string
-  // Per-assistant-segment cumulative text — used at turn close to strip
-  // [[send: /path]] markers and replace each segment with a cleaned
-  // version, then post the files as separate Feishu messages.
-  segmentTexts: Map<string, string>
-  startedAt: number
-}
-
-export type Status = 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'
-
-export interface SessionOpts {
-  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions'
-}
-
-/** Per-turn delta extracted from the SDK `result` message — feeds the
- * "上一轮" line in the console panel. */
-export interface LastTurnDelta {
-  tokens: number      // input + cache_* + output for that turn
-  costUsd: number
-  durationMs: number
-  inputTokens: number // input + cache_* (excludes output) — context-window estimate
-}
-
-/** Cumulative session counters. Reset on full restart (`clear`),
- * preserved across `restart`/resume and daemon-restart so the `hi`
- * panel reflects the user's total spend in this conversation
- * regardless of how many times the underlying ClaudeProcess has been
- * respawned. Resumed conversations start counting from the resume
- * point onward — the SDK doesn't replay historical usage on resume,
- * so a long pre-resume conversation shows up as zero here until the
- * first new turn lands. */
-export interface CumStats {
-  tokens: number
-  costUsd: number
-  turns: number
-}