kira-glasses-bridge 2.14.0 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Connects your Mac to Kira, the assistant for Even G2 glasses: Claude Code sessions, files, folders and apps, by voice.",
   "type": "module",
   "bin": {

package/src/agents/claude.mjs

@@ -191,11 +191,24 @@ export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io
     return applyAnswer(toolName, input, request, resolved.answer, suggestions)
   }
 
+  // Background work (subagents, `run_in_background` shell commands, monitors)
+  // started by the model would outlive the turn: this is a one-shot run, so the
+  // moment the main thread stops the result is released, the process ends and
+  // that work is killed, never having reported. Claude's parting words ("the
+  // agents are still running; I'll compile the report when they finish") then
+  // became the job's final report, and Kira told the user it was still going.
+  // With this set, the tool has no background option: subagents run inline and
+  // their findings are in the answer.
+  const env = { ...process.env, CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: '1' }
+  /** Background tasks the model still managed to start (an older CLI ignoring the flag): tool_use id -> description. */
+  const orphans = new Map()
+
   try {
     const q = query({
       prompt,
       options: {
         cwd,
+        env,
         ...(sessionId ? { resume: sessionId } : {}),
         permissionMode: 'default',
         ...(abort ? { abortController: abort } : {}),
@@ -211,18 +224,26 @@ export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io
       },
     })
     for await (const m of q) {
+      // Messages from inside a subagent carry the id of the Subtask call that started it.
+      const nested = !!m.parent_tool_use_id
       if (m.type === 'system' && m.subtype === 'init') {
         session = m.session_id ?? session
         io.emit({ kind: 'session', sessionId: session, model: m.model ?? null })
+      } else if (m.type === 'system' && m.subtype === 'task_started') {
+        if (m.is_backgrounded && m.tool_use_id) orphans.set(m.tool_use_id, m.description ?? m.subagent_type ?? 'task')
+      } else if (m.type === 'system' && m.subtype === 'task_notification') {
+        if (m.tool_use_id) orphans.delete(m.tool_use_id)
       } else if (m.type === 'assistant') {
         for (const b of m.message?.content ?? []) {
-          if (b.type === 'text' && b.text?.trim()) io.emit({ kind: 'message', text: short(b.text, TEXT_CAP) })
+          // A subagent's narration is for its parent, not the user; its actions still show what is going on while the Subtask runs.
+          if (b.type === 'text' && b.text?.trim() && !nested) io.emit({ kind: 'message', text: short(b.text, TEXT_CAP) })
           else if (b.type === 'tool_use') io.emit({ kind: 'action', id: b.id, tool: b.name, ...describeAction(b.name, b.input, cwd) })
         }
       } else if (m.type === 'user') {
         for (const b of m.message?.content ?? []) {
           if (b?.type === 'tool_result') {
             const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map(c => (c.type === 'text' ? c.text : '')).join('\n') : ''
+            if (/^Async agent launched successfully/.test(t.trim()) && !orphans.has(b.tool_use_id)) orphans.set(b.tool_use_id, 'subagent')
             io.emit({ kind: 'action_result', id: b.tool_use_id, ok: !b.is_error, preview: short(t.trim(), 240) })
           }
         }
@@ -230,6 +251,11 @@ export async function run({ prompt, sessionId, cwd, policy, persona, abort }, io
         session = m.session_id ?? session
         if (m.subtype === 'success') text = String(m.result ?? '')
         else error = `Claude stopped: ${m.subtype}${Array.isArray(m.errors) && m.errors.length ? ` (${m.errors.join('; ').slice(0, 300)})` : ''}`
+        // Work left running in the background dies with this process; say so rather than let "still running" stand as the outcome.
+        if (orphans.size) {
+          const note = `${orphans.size} background ${orphans.size === 1 ? 'task was' : 'tasks were'} still running when Claude ended its turn (${[...orphans.values()].slice(0, 5).join(', ')}); they were stopped with the session and their findings are not in this report. Send a follow-up to have that work done inline.`
+          text = text ? `${text}\n\n(${note})` : `(${note})`
+        }
         const stats = { durationMs: m.duration_ms, turns: m.num_turns, costUsd: m.total_cost_usd }
         io.emit({ kind: 'result', ok: !error, text: short(text, TEXT_CAP), error, sessionId: session, stats })
         return { ok: !error, text, error, sessionId: session, stats }

package/src/claude-designs.mjs

@@ -155,14 +155,16 @@ async function designsOf(s) {
 }
 
 /**
- * Scan every session changed since `since` (ISO time; all of them when omitted). Returns the
- * designs without their HTML, plus the HTML of those whose hash isn't in `known` (hashes the API
- * already holds), so a rescan sends only what changed.
+ * Scan every session changed since `since` (ISO time; all of them when omitted), or only the
+ * sessions named in `sessions` (a Claude job just finished in one). Returns the designs without
+ * their HTML, plus the HTML of those whose hash isn't in `known` (hashes the API already holds),
+ * so a rescan sends only what changed.
  */
-export async function scanDesigns({ since, known = [] } = {}) {
+export async function scanDesigns({ since, known = [], sessions: only } = {}) {
   const after = since ? Date.parse(since) || 0 : 0
   const have = new Set(known)
-  const sessions = (await sdkListSessions()).filter(s => s.lastModified > after)
+  const pick = Array.isArray(only) && only.length ? new Set(only) : null
+  const sessions = (await sdkListSessions()).filter(s => (pick ? pick.has(s.sessionId) : s.lastModified > after))
   const designs = []
   let failed = 0
   for (const s of sessions) {

package/src/index.mjs

@@ -45,6 +45,7 @@ const ANSWER_TIMEOUT_MS = 3 * 60 * 1000
  *   openTerminal({ cwd, command })   open_terminal in the app's own terminal (a Kira tab), not
  *                           Terminal.app; resolves to what to report, or null to fall back
  *   terminals               the app's shells, for remote devices (terminals.mjs)
+ *   browser({ op, … })      Kira in the app's browser dock: open, read, click, type (browser-kira.mjs)
  */
 let hooks = {}
 let stopped = false
@@ -112,7 +113,7 @@ const tools = {
     return listProjects(args.max)
   },
   async scan_claude_designs(args) {
-    return scanDesigns({ since: args.since, known: Array.isArray(args.known) ? args.known : [] })
+    return scanDesigns({ since: args.since, known: Array.isArray(args.known) ? args.known : [], sessions: args.sessions })
   },
   async list_claude_sessions(args) {
     return listSessions(args.max)
@@ -198,6 +199,12 @@ const tools = {
   /** This Mac's shells for a browser elsewhere (only inside the Mac app, only when switched on there). */
   terminal: args => terminalCall(args),
 
+  /** Kira in the Mac app's browser dock: open a page, read it, click and type in it. */
+  async browser(args) {
+    if (!hooks.browser) return { error: 'the browser needs the Kira Mac app (this bridge has none)', reason: 'unavailable' }
+    return hooks.browser(args)
+  },
+
   /** Open a terminal on this Mac in a folder and run a command there (used to hand a Claude session
    *  to the person): a Kira tab when the bridge runs inside the Mac app, else Terminal.app. */
   async open_terminal(args) {