kira-glasses-bridge 2.32.0 → 2.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kira-glasses-bridge",
-  "version": "2.32.0",
+  "version": "2.34.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-calls.mjs

@@ -58,6 +58,7 @@ export function describeAction(name, input, cwd) {
       return act('fetch', 'Fetch', short(i.url, 200))
     case 'WebSearch':
       return act('fetch', 'Search the web', short(i.query, 160))
+    case 'Agent':
     case 'Task':
       return act('delegate', 'Subtask', short(i.description ?? i.prompt, 160))
     case 'TodoWrite':

package/src/agents/claude.mjs

@@ -15,6 +15,8 @@ import { planLimits } from './claude-local.mjs'
 import { contextFrom, limitsFromEvent, rejectedWindow, stoppedBy } from './claude-usage.mjs'
 import { sdkOptionsFor } from './settings.mjs'
 import { kiraPluginOptions } from '../kira-plugin.mjs'
+import { git } from '../git.mjs'
+import { isAgentCall, subagentFeed } from './subagents.mjs'
 
 /** Kira's MCP server as Claude Code connects to it: Streamable HTTP, the token as the bearer. */
 const kiraServer = ({ url, token }) => ({ type: 'http', url, headers: { Authorization: `Bearer ${token}` } })
@@ -100,6 +102,9 @@ async function run({ prompt, sessionId, cwd, persona, settings, abort }, io) {
   const env = { ...process.env, CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: '1', ENABLE_CLAUDEAI_MCP_SERVERS: 'false' }
   /** Background tasks the model still managed to start (an older CLI ignoring the flag): tool_use id -> description. */
   const orphans = new Map()
+  /** The agents it starts, each with where it works (subagents.mjs). */
+  const branchOf = async path => (await git(path, ['branch', '--show-current']))?.trim() || null
+  const agents = subagentFeed(e => io.emit(e), branchOf)
 
   try {
     const q = query({
@@ -144,6 +149,9 @@ async function run({ prompt, sessionId, cwd, persona, settings, abort }, io) {
         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)
+        if (m.tool_use_id) agents.ended(m.tool_use_id, m.status, m.summary)
+      } else if (m.type === 'system' && m.subtype === 'task_progress') {
+        if (m.tool_use_id) agents.progress(m.tool_use_id, m.summary)
       } else if (m.type === 'assistant') {
         // A new turn of the main thread: how full the context is now, as /context counts it (no model call).
         if (!nested && m.message?.id && m.message.id !== turn) {
@@ -153,7 +161,13 @@ async function run({ prompt, sessionId, cwd, persona, settings, abort }, io) {
         for (const b of m.message?.content ?? []) {
           // 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 (b.type === 'tool_use') {
+            // A step inside an agent says whose it is.
+            const whose = nested ? { agent: m.parent_tool_use_id } : {}
+            io.emit({ kind: 'action', id: b.id, tool: b.name, ...describeAction(b.name, b.input, cwd), ...whose })
+            if (isAgentCall(b.name)) agents.called(b.id, b.input, m.parent_tool_use_id)
+            if (nested) agents.touched(m.parent_tool_use_id, b.input)
+          }
         }
       } else if (m.type === 'user') {
         for (const b of m.message?.content ?? []) {
@@ -161,10 +175,12 @@ async function run({ prompt, sessionId, cwd, persona, settings, abort }, io) {
             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) })
+            if (agents.has(b.tool_use_id)) agents.returned(b.tool_use_id, m.tool_use_result, b.is_error)
           }
         }
       } else if (m.type === 'result') {
         session = m.session_id ?? session
+        agents.stopAll()
         // A turn that ended on an API error (a usage limit among them) is a success carrying the error.
         const limit = { limits: usage.known, rejected, limitPrefixes: USAGE_LIMIT_ERROR_PREFIXES }
         if (m.subtype === 'success' && !m.is_error) text = String(m.result ?? '')

package/src/agents/codex-items.mjs

@@ -79,6 +79,8 @@ export function itemAction(item, cwd) {
     case 'plan':
       return act('plan', 'Plan', short(item.text, 160), { tool: 'Plan' })
     case 'collabAgentToolCall':
+      // Spawning one is a step; waiting on or messaging its agents moves the agent's row (codex-subagents.mjs).
+      if (item.tool !== 'spawnAgent') return null
       return act('delegate', 'Subtask', short(item.prompt ?? '', 160), { tool: 'Subtask' })
     case 'enteredReviewMode':
       return act('read', 'Review', short(item.review ?? '', 160), { tool: 'Review' })

package/src/agents/codex-subagents.mjs

@@ -0,0 +1,60 @@
+// The agents Codex spawns inside a turn (its collab tools), as protocol `agent` events, the way
+// subagents.mjs does Claude Code's. A spawn is a collabAgentToolCall naming the new agent's thread;
+// that thread's items then arrive on the same app server, so each one says whose it is (`whose`), and
+// later collab calls and subAgentActivity items say how each agent stands. Codex's agents work in the
+// turn's own folder.
+import { short } from './claude-calls.mjs'
+
+const STATES = {
+  completed: 'done',
+  errored: 'failed',
+  interrupted: 'stopped',
+  shutdown: 'stopped',
+  notFound: 'stopped',
+}
+const ACTIVITY = { completed: 'done', interrupted: 'stopped' }
+
+/** The last part of an agent's path ("/root/explorer" → "explorer"): the name Codex gave it. */
+const nameOf = path => String(path ?? '').split('/').filter(Boolean).pop() || null
+
+export function codexAgentFeed(emit) {
+  const agents = new Map()
+  /** Each agent's thread, to the spawn call that made it. */
+  const threads = new Map()
+  const send = a => {
+    agents.set(a.id, a)
+    emit(a)
+  }
+  const settle = (threadId, status, name) => {
+    const a = agents.get(threads.get(threadId))
+    if (!a) return
+    const named = name && !a.name ? { name } : {}
+    if (status && a.status === 'running') send({ ...a, status, ...named })
+    else if (named.name) send({ ...a, ...named })
+  }
+  return {
+    /** The agent a thread's items belong to, if the thread is one Codex spawned. */
+    whose: threadId => threads.get(threadId) ?? null,
+    started(item) {
+      if (item.type !== 'collabAgentToolCall' || item.tool !== 'spawnAgent') return
+      const description = short(item.prompt ?? '', 200)
+      send({ kind: 'agent', id: item.id, type: 'agent', description, status: 'running' })
+    },
+    completed(item) {
+      if (item.type === 'subAgentActivity') {
+        return settle(item.agentThreadId, ACTIVITY[item.kind], nameOf(item.agentPath))
+      }
+      if (item.type !== 'collabAgentToolCall') return
+      if (item.tool === 'spawnAgent') {
+        for (const t of item.receiverThreadIds ?? []) threads.set(t, item.id)
+        const a = agents.get(item.id)
+        if (a && item.status === 'failed') send({ ...a, status: 'failed' })
+      }
+      for (const [t, state] of Object.entries(item.agentsStates ?? {})) settle(t, STATES[state?.status])
+    },
+    /** The turn ended: what still runs ended with it (`status`: done, or stopped when it was cut short). */
+    endAll(status) {
+      for (const a of agents.values()) if (a.status === 'running') send({ ...a, status })
+    },
+  }
+}

package/src/agents/codex.mjs

@@ -9,6 +9,7 @@ import { codexBin, openCodex } from './codex-rpc.mjs'
 import { codexInput } from './codex-input.mjs'
 import { turnSteering } from './codex-steer.mjs'
 import { codexStream } from './codex-live.mjs'
+import { codexAgentFeed } from './codex-subagents.mjs'
 import { liveEmitter } from './live.mjs'
 import { kiraDecides } from './checks.mjs'
 import { CODEX_ASKS, askPerson, refusedByPolicy, said } from './codex-ask.mjs'
@@ -51,6 +52,8 @@ async function run({ prompt, attachments, sessionId, cwd, persona, settings, abo
   /** What is still being written (live.mjs): sent as it comes, the final form of each kept. */
   const live = liveEmitter(io.emit)
   const stream = codexStream()
+  /** The agents it spawns, and which thread is whose (codex-subagents.mjs). */
+  const agents = codexAgentFeed(e => io.emit(e))
   let finished
   const ended = new Promise(resolve => (finished = resolve))
   // What the person says while a turn runs goes into it (`codex` is the app server, opened below).
@@ -86,16 +89,22 @@ async function run({ prompt, attachments, sessionId, cwd, persona, settings, abo
   }
 
   const onNotify = (method, p) => {
+    // An item from a thread Codex spawned is its agent's: its steps say so, and what it says is for Codex.
+    const whose = p?.threadId ? agents.whose(p.threadId) : null
     const update = stream.update(method, p)
-    if (update) return live.update(update)
+    if (update) return whose ? undefined : live.update(update)
     if (method === 'item/started') {
       if (p.item.type === 'fileChange') changes.set(p.item.id, p.item.changes ?? [])
+      agents.started(p.item)
       const action = itemAction(p.item, cwd)
-      if (action) io.emit({ kind: 'action', id: p.item.id, ...action })
+      if (action) io.emit({ kind: 'action', id: p.item.id, ...action, ...(whose ? { agent: whose } : {}) })
     } else if (method === 'item/completed') {
+      agents.completed(p.item)
       const reviewed = review.completed(p.item)
       if (reviewed) io.emit(reviewed)
-      if (p.item.type === 'agentMessage' && p.item.text?.trim()) {
+      if (whose && p.item.type === 'agentMessage') {
+        // Its agent's answer goes to Codex, not the person.
+      } else if (p.item.type === 'agentMessage' && p.item.text?.trim()) {
         text = p.item.text
         if (!review.repeats(text)) live.final({ kind: 'message', id: p.item.id, text: short(p.item.text, TEXT_CAP) })
       } else if (itemAction(p.item, cwd)) {
@@ -117,6 +126,7 @@ async function run({ prompt, attachments, sessionId, cwd, persona, settings, abo
       steering.ended()
       if (t.status === 'failed') error = usage.stopped(stoppedBy(t.error ?? { message: 'failed' }, usage.limits))
       if (t.status === 'interrupted') error = 'Stopped by the user.'
+      agents.endAll(t.status === 'completed' ? 'done' : 'stopped')
       finished({ durationMs: t.durationMs ?? undefined })
     }
   }

package/src/agents/protocol.mjs

@@ -10,7 +10,13 @@
 //   action           { kind, id, type, tool, label, target, note?, detail? }
 //                      type: read | search | edit | write | run | fetch | delegate | plan | other
 //                      detail: { edit: {old,new,all} | edits: [...] | content | command }
+//                      agent: the id of the agent (below) whose step it is, when an agent the turn started took it
 //   action_result    { kind, id, ok, preview? }
+//   agent            { kind, id, type, description, status, name?, isolated?, background?, summary?,
+//                      worktree?: { path, branch? }, stats?: { tools?, ms?, adds?, dels? }, agent? }
+//                      an agent the turn started (Claude Code's Agent tool, Codex's spawnAgent), sent again whole
+//                      each time it changes; status: running | done | failed | stopped; worktree: its own, when it
+//                      has one (subagents.mjs, codex-subagents.mjs)
 //   request          { kind, request: AgentRequest }        needs a person; the job waits
 //   request_resolved { kind, id, answer, by }              by: voice | lens | phone | portal | timeout | policy
 //   usage            { kind, context: {used,window} | null, limits: AgentLimits | null }   how full the thread

package/src/agents/subagents.mjs

@@ -0,0 +1,121 @@
+// The agents Claude Code starts inside a turn (its Agent tool, once called Task), as protocol `agent`
+// events: what kind each is, what it was asked, how it's going, and where it works: the job's folder,
+// or a worktree of its own (`isolation: "worktree"`, under <repo>/.claude/worktrees/<name>). Its own
+// steps carry its id as `agent` (claude.mjs); the worktree shows up in the first path one of them
+// touches, and the finished call names it too. Each change of an agent is the whole event again, so
+// the last one with an id is where it stands.
+import { display } from '../git.mjs'
+
+/** Claude Code's tool for starting an agent, by its current name and its old one. */
+export const isAgentCall = name => name === 'Agent' || name === 'Task'
+
+const WORKTREE = /^(.*\/\.claude\/worktrees\/[^/]+)(?:\/|$)/
+
+/** The agent worktree a path is inside, if any. */
+export function worktreeOf(path) {
+  const m = WORKTREE.exec(String(path ?? ''))
+  return m ? m[1] : null
+}
+
+/** Every absolute path a tool call names, for finding where an agent works. */
+export function pathsIn(input) {
+  const i = input ?? {}
+  const named = [i.file_path, i.notebook_path, i.path].filter(p => typeof p === 'string')
+  const cd = /(?:^|&&|;)\s*cd\s+("[^"]+"|'[^']+'|\S+)/.exec(String(i.command ?? ''))
+  if (cd) named.push(cd[1].replace(/^["']|["']$/g, ''))
+  return named.filter(p => p.startsWith('/'))
+}
+
+/** An Agent call as the agent it starts. */
+export function agentFrom(id, input, parent) {
+  const i = input ?? {}
+  return {
+    kind: 'agent',
+    id,
+    type: String(i.subagent_type || 'general-purpose'),
+    description: String(i.description || i.prompt || '').slice(0, 200),
+    status: 'running',
+    ...(i.name ? { name: String(i.name) } : {}),
+    ...(i.isolation === 'worktree' ? { isolated: true } : {}),
+    ...(parent ? { agent: parent } : {}),
+  }
+}
+
+/** A finished Agent call's result (the SDK's tool_use_result): how it went, where, and what it did. */
+export function finished(agent, result, failed) {
+  const r = result && typeof result === 'object' ? result : {}
+  if (r.status === 'async_launched') return { ...agent, background: true }
+  const s = r.toolStats
+  const stats = {
+    ...(typeof r.totalToolUseCount === 'number' ? { tools: r.totalToolUseCount } : {}),
+    ...(typeof r.totalDurationMs === 'number' ? { ms: r.totalDurationMs } : {}),
+    ...(s ? { adds: s.linesAdded ?? 0, dels: s.linesRemoved ?? 0 } : {}),
+  }
+  // Claude Code removes an agent's worktree when it changed nothing, and then doesn't name it.
+  const removed = r.status === 'completed' && agent.isolated
+  const worktree = r.worktreePath
+    ? { path: display(r.worktreePath), ...(r.worktreeBranch ? { branch: r.worktreeBranch } : {}) }
+    : removed
+      ? null
+      : agent.worktree
+  const { worktree: _, ...rest } = agent
+  return {
+    ...rest,
+    status: failed ? 'failed' : 'done',
+    ...(worktree ? { worktree } : {}),
+    ...(Object.keys(stats).length ? { stats } : {}),
+  }
+}
+
+const ENDED = { completed: 'done', failed: 'failed', stopped: 'stopped' }
+
+/**
+ * A turn's agents as they go. `emit` sends each change; `branchOf(path)` reads a worktree's branch
+ * (git, or a stand-in in tests).
+ */
+export function subagentFeed(emit, branchOf) {
+  const agents = new Map()
+  const send = (a, more = {}) => {
+    agents.set(a.id, a)
+    emit({ ...a, ...more })
+  }
+  return {
+    has: id => agents.has(id),
+    /** The Agent call: it starts. */
+    called(id, input, parent) {
+      send(agentFrom(id, input, parent))
+    },
+    /** One of its own calls: the first path inside a worktree says which one it works in. */
+    touched(id, input) {
+      const a = agents.get(id)
+      if (!a || a.worktree) return
+      const path = pathsIn(input).map(worktreeOf).find(Boolean)
+      if (!path) return
+      send({ ...a, worktree: { path: display(path) } })
+      void Promise.resolve(branchOf(path)).then(branch => {
+        const now = agents.get(id)
+        if (branch && now?.worktree && !now.worktree.branch) send({ ...now, worktree: { ...now.worktree, branch } })
+      })
+    },
+    /** A one-line summary of where it's at, while it works: shown live, never stored. */
+    progress(id, summary) {
+      const a = agents.get(id)
+      if (a && summary) emit({ ...a, summary: String(summary).slice(0, 200), transient: true })
+    },
+    /** Its call's result: done, or still going in the background. */
+    returned(id, result, failed) {
+      const a = agents.get(id)
+      if (a) send(finished(a, result, failed))
+    },
+    /** A background agent ended (task_notification). */
+    ended(id, status, summary) {
+      const a = agents.get(id)
+      if (a?.status !== 'running') return
+      send({ ...a, status: ENDED[status] ?? 'done', ...(summary ? { summary: String(summary).slice(0, 200) } : {}) })
+    },
+    /** The turn ended: whatever still runs stops with it. */
+    stopAll() {
+      for (const a of agents.values()) if (a.status === 'running') send({ ...a, status: 'stopped' })
+    },
+  }
+}