picocode-core 0.9.135 → 0.9.137

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picocode-core",
-  "version": "0.9.135",
+  "version": "0.9.137",
   "description": "The agent runtime behind pico: sessions, tools, subagents, MCP, memory, and model access",
   "type": "module",
   "license": "MIT",

package/src/agent-transcript.js

@@ -33,25 +33,40 @@ function settleTool(tools, event) {
   item.fullOutput = event.result === undefined ? null : typeof event.result === 'string' ? event.result : JSON.stringify(event.result, null, 2)
 }
 
+// a deliberation reads as turns: each turn owns the tool runs its
+// participant made before speaking. every recorded event carries the
+// speaker's role and round, so a turn opens on its first tool call and
+// closes when its text arrives; a turn with tools and no text is running
 function deliberationTranscript(agent) {
   const items = [{ kind: 'user', text: agent.prompt }]
   const tools = new Map()
+  const turns = new Map()
+  const turnFor = (role, round) => {
+    const key = `${role}:${round}`
+    if (!turns.has(key)) {
+      const turn = { kind: 'deliberation-turn', role, round, text: null, tools: [], active: agent.status === 'running' }
+      turns.set(key, turn)
+      items.push(turn)
+    }
+    return turns.get(key)
+  }
   for (const entry of agent.timeline) {
     if (entry.kind === 'turn') {
-      const turn = entry.value
-      items.push({ kind: 'deliberation-turn', role: turn.role, round: turn.round, text: turn.text })
+      const turn = turnFor(entry.value.role, entry.value.round)
+      turn.text = entry.value.text
+      turn.active = false
       continue
     }
     const event = entry.value
     if (event.type === 'tool_executing') {
       const item = toolItem(event.call || {}, event.at)
       tools.set(item.callId, item)
-      items.push(item)
+      turnFor(event.role, event.round).tools.push(item)
     }
     if (event.type === 'tool_complete' || event.type === 'tool_error') settleTool(tools, event)
   }
   if (agent.result) {
-    items.push({ kind: 'deliberation-turn', role: 'synthesis', text: agent.result, interrupted: agent.status === 'cancelled' })
+    items.push({ kind: 'deliberation-turn', role: 'synthesis', text: agent.result, tools: [], interrupted: agent.status === 'cancelled' })
   } else if (agent.error) {
     items.push({ kind: 'assistant', text: agent.error, interrupted: true })
   }

package/src/controller.js

@@ -28,6 +28,7 @@ import { connectOpenAI, openaiCredentials, disconnectOpenAI } from './openai-aut
 import { agentScratchDir, ensureDir } from './paths.js'
 import { loadCodexModels } from './codex-models.js'
 import { fuzzyScore } from './fuzzy.js'
+import { MAX_DELIBERATION_ROUNDS } from './deliberation.js'
 import { buildUserContent, finalizeUserContent, inputTextFromContent, mediaTypeFor } from './attachments.js'
 
 export const EFFORT_LEVELS = [
@@ -73,8 +74,9 @@ function parallelPrompt(task, agentLimit) {
   return `Use parallel agents for the following task: ${task}\n\nFirst call agent_plan. Interpret any agent-count instruction in the user's task semantically and declare that count; if the user gave no count, declare the configured default budget of ${agentLimit}. Then use agent_start within that enforced budget to delegate distinct, focused parts of the task to the configured worker model. Collect workers with agent_collect, critically evaluate their results, and synthesize the final response. When useful and the budget permits, use independent workers to check important disputed or weak conclusions. Do not delegate final synthesis. Do not emit progress updates while agents run; Pico displays agent activity automatically.`
 }
 
-function deliberatePrompt(decision) {
-  return `Deliberate on the following decision: ${decision}\n\nImmediately call deliberate with a self-contained brief. Do not research first, start ordinary agents, or approximate the deliberation yourself. The deliberation participants own all supporting research.`
+function deliberatePrompt(decision, rounds) {
+  const withRounds = rounds ? ` and rounds set to ${rounds}` : ''
+  return `Deliberate on the following decision: ${decision}\n\nImmediately call deliberate with a self-contained brief${withRounds}. Do not research first, start ordinary agents, or approximate the deliberation yourself. The deliberation participants own all supporting research.`
 }
 
 function workerSystemPrompt(scratchpad) {
@@ -985,13 +987,16 @@ export function createController({ boot }) {
     return true
   }
 
-  function sendDeliberate(decision) {
+  // rounds, when given, is passed along to the tool call; the tool itself
+  // clamps to its 1..5 range
+  function sendDeliberate(decision, rounds) {
     if (!decision) {
       flash('usage: /deliberate <decision>')
       return true
     }
     if (!modelAvailable(boot.deliberationModel)) return false
-    send(deliberatePrompt(decision))
+    const n = Number(rounds)
+    send(deliberatePrompt(decision, Number.isInteger(n) && n >= 1 && n <= MAX_DELIBERATION_ROUNDS ? n : null))
     return true
   }