@bill10/agent-007 0.14.2 → 0.15.1000

package/VERSION

@@ -1 +1 @@
-0.14.0.2
+0.15.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bill10/agent-007",
-  "version": "0.14.2",
+  "version": "0.15.1000",
   "description": "From web terminals for your coding agents to a self-running agent company: Claude Code and Codex in parallel git worktrees, a job board they pick work from, and one agent that runs the board from a goal.",
   "license": "MIT",
   "repository": {

package/public/modules/waiting.js

@@ -128,7 +128,7 @@ function openCard(item) {
 function answeredRow(item) {
   const li = el('li', 'waiting-answered-item');
   li.append(el('span', 'waiting-card-n', `Q${item.n}`), el('span', 'waiting-answered-text', item.text));
-  const via = item.answeredVia === 'telegram' ? 'Telegram' : 'app';
+  const via = { telegram: 'Telegram', terminal: 'terminal' }[item.answeredVia] || 'app';
   li.appendChild(el('span', 'waiting-answered-answer', `→ ${item.answer} · ${via} · ${ago(item.answeredAt)}`));
   return li;
 }

package/server/billion.js

@@ -134,12 +134,30 @@ export function suggestProjectsDir(repoPaths, { ignoreUnder = CONFIG_DIR } = {})
 }
 
 
+// Claude Code keeps each deferred tool's definition from the moment a
+// conversation first loads it (a deferred_tools_record in the transcript), and
+// a resumed conversation goes on using that copy, as it does the MCP server's
+// instructions. A fresh tools/list, notifications/tools/list_changed and
+// loading the tool again with ToolSearch all leave it (Claude Code 2.1.283). So an
+// upgrade that changes a board tool leaves a resumed Billion reading the old
+// one. Its calls still reach this server, which takes the new fields, so
+// Billion only needs telling. This saves the current definitions to file and
+// returns the names that differ from the last saved copy: all of them when
+// there is none, since the conversation may predate any of them.
+export function changedBoardTools(file, tools) {
+  let saved = [];
+  try { saved = JSON.parse(readFileSync(file, 'utf8')); } catch {}
+  const before = new Map((Array.isArray(saved) ? saved : []).map(t => [t?.name, JSON.stringify(t)]));
+  writeFileSync(file, `${JSON.stringify(tools, null, 2)}\n`);
+  return tools.filter(t => before.get(t.name) !== JSON.stringify(t)).map(t => t.name);
+}
+
 // Everything Billion must do lives in its charter; the prompt only says which
 // part applies. A fresh repo gets the introduction. Any later start says both,
 // because a restart can land mid-introduction: the charter tells it to finish
 // the introduction while STATE.md still says "not started". --continue only
 // when a conversation exists, so a lost transcript still starts cleanly.
-export function billionCommand({ created, hasConversation, dir, projectsHint }) {
+export function billionCommand({ created, hasConversation, dir, projectsHint, changedTools = [], toolsFile }) {
   const where = `Your folder is ${dir}.`;
   const hint = projectsHint
     ? `Suggest ${projectsHint} as the projects folder: most of the owner's repos are there.`
@@ -147,7 +165,11 @@ export function billionCommand({ created, hasConversation, dir, projectsHint })
   const prompt = created
     ? `This is your first run. Introduce yourself as described in CHARTER.md under "First run". ${where} ${hint}`
     : `You were restarted. If STATE.md still says "Status: not started", do or finish your introduction (CHARTER.md, "First run"). ${hint} Otherwise start your operating loop (CHARTER.md, "Operating loop"). ${where}`;
-  return `claude --dangerously-skip-permissions${!created && hasConversation ? ' --continue' : ''} ${quote(prompt)}`;
+  const resumed = !created && hasConversation;
+  const stale = resumed && changedTools.length && toolsFile
+    ? ` Agent 007 changed these board tools since you last started: ${changedTools.join(', ')}. This conversation keeps the definitions it first loaded, so yours are out of date, and loading them again does not help. Read the current ones in ${toolsFile} and call those tools by it: the board accepts the new fields even where your copy does not list them.`
+    : '';
+  return `claude --dangerously-skip-permissions${resumed ? ' --continue' : ''} ${quote(prompt + stale)}`;
 }
 
 // Billion is Claude Code. Without it, its tab runs this instead: one line

package/server/http.js

@@ -17,7 +17,7 @@ import { expandHome } from '../lib/helpers.js';
 import { requestApproval, answerApproval, readApproval } from './approvals.js';
 import { agentSummaries, sendMessage, flushMessages, pendingMessages, readAgentScreen } from './messages.js';
 import { handleMcpMessage } from './mcp.js';
-import { notifyOwner, tellOwner } from './owner.js';
+import { notifyOwner, tellOwner, resolveQuestion } from './owner.js';
 import { availableModels } from './models.js';
 
 // --- Origin Check Middleware (B2) ---
@@ -141,6 +141,9 @@ export function setupRoutes(app, staticDir, { broadcast, killSession, respawnAge
         tellOwner: (text) => (req.agentSession.isBillion
           ? tellOwner(text)
           : { error: 'Only Billion can message the owner.' }),
+        resolveQuestion: (ref, answer) => (req.agentSession.isBillion
+          ? resolveQuestion(ref, answer, { broadcast })
+          : { error: 'Only Billion can resolve the owner\'s questions.' }),
         // Never logged: a screen can hold a secret that scrolled by.
         readAgentScreen: ({ name, lines }) => readAgentScreen({
           from: req.agentSession, name, lines, sessions,

package/server/mcp.js

@@ -399,6 +399,25 @@ export const TELL_OWNER_TOOL = {
   },
 };
 
+export const RESOLVE_QUESTION_TOOL = {
+  name: 'resolve_question',
+  description:
+    'Close a "Waiting on you" question the owner answered somewhere else, such as '
+    + 'typing in this terminal, so the tab and their phone do not hold it open. '
+    + 'Marks it answered with your summary of their answer; nothing comes back '
+    + 'here. Name it by number (3 for Q3) or id.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      number: { type: 'integer', minimum: 1, description: 'The question\'s number: 3 for Q3.' },
+      id: { type: 'string', description: 'The question\'s id, instead of number.' },
+      answer: { type: 'string', description: 'The owner\'s answer, as they gave it.' },
+    },
+    required: ['answer'],
+    additionalProperties: false,
+  },
+};
+
 // Billion's too: reading is narrower than messaging (server/messages.js,
 // readAgentScreen), so it is only for the workers on Billion's own cards.
 export const READ_AGENT_SCREEN_TOOL = {
@@ -445,7 +464,7 @@ export const RESPAWN_AGENT_TOOL = {
 };
 
 export const TOOLS = [POST_JOB_TOOL, LIST_JOBS_TOOL, READ_JOB_TOOL, EDIT_JOB_TOOL, FINISH_JOB_TOOL, LIST_AGENTS_TOOL, SEND_MESSAGE_TOOL];
-const BILLION_TOOLS = [BILLION_READY_TOOL, ADD_REPO_TOOL, CLOSE_JOB_TOOL, ANSWER_PERMISSION_TOOL, READ_APPROVAL_TOOL, NOTIFY_OWNER_TOOL, TELL_OWNER_TOOL, READ_AGENT_SCREEN_TOOL, RESPAWN_AGENT_TOOL];
+const BILLION_TOOLS = [BILLION_READY_TOOL, ADD_REPO_TOOL, CLOSE_JOB_TOOL, ANSWER_PERMISSION_TOOL, READ_APPROVAL_TOOL, NOTIFY_OWNER_TOOL, TELL_OWNER_TOOL, RESOLVE_QUESTION_TOOL, READ_AGENT_SCREEN_TOOL, RESPAWN_AGENT_TOOL];
 
 // `models` is { claude: [...], codex: [...] } as server/models.js last found them.
 export function toolsFor(session, models) {
@@ -693,6 +712,15 @@ const CALLS = {
     return toolText('Sent to the owner on Telegram.');
   },
 
+  [RESOLVE_QUESTION_TOOL.name]: async (args, ctx) => {
+    if (args.number === undefined && !args.id) return toolText('Name the question by number or id.', true);
+    const result = ctx.resolveQuestion
+      ? await ctx.resolveQuestion({ number: args.number, id: args.id }, args.answer)
+      : { error: 'Only Billion can resolve the owner\'s questions.' };
+    if (result.error) return toolText(result.error, true);
+    return toolText(`Q${result.item.n} is marked answered: ${result.item.answer}`);
+  },
+
   // Quoted line by line, like a message body, so the screen cannot pass for
   // anything but a quote — nor close the block and carry on as the server.
   [READ_AGENT_SCREEN_TOOL.name]: (args, ctx) => {

package/server/owner.js

@@ -175,8 +175,8 @@ async function transcribeNote(note, env) {
 // --- The "Waiting on you" list, in the config dir so it survives restarts ---
 //
 // An item: { id, n, text, at, choices?, recommended?, status, answer?,
-// answeredAt?, answeredVia?, tgMessageId?, tgVoice? }. n is the short number
-// the owner sees (Q3). status is open, answered or dismissed. Items written
+// answeredAt?, answeredVia?, tgMessageId?, tgVoice? }. answeredVia is app,
+// telegram or terminal (resolve_question). n is the short number the owner sees (Q3). status is open, answered or dismissed. Items written
 // before v0.10 have neither n nor status: they read as open, numbered in order.
 
 const waitingPath = () => join(CONFIG_DIR, 'waiting.json');
@@ -264,16 +264,38 @@ export async function answerWaiting(id, answer, via, { broadcast, env = process.
   if (!sendText(billion, answerLine(via === 'app' ? APP_PREFIX : OWNER_PREFIX, item, body))) {
     return { error: 'Billion has too much waiting for it; try again in a while.' };
   }
-  const done = updateWaiting(id, { status: 'answered', answer: body, answeredAt: new Date().toISOString(), answeredVia: via });
+  return { ok: true, item: await markAnswered(id, body, via, { broadcast, env }) };
+}
+
+// Answered everywhere: the item moves to Answered in every browser, and the
+// phone's copy shows the answer.
+async function markAnswered(id, answer, via, { broadcast, env }) {
+  const done = updateWaiting(id, { status: 'answered', answer, answeredAt: new Date().toISOString(), answeredVia: via });
   broadcast?.(waitingPayload());
   if (done.tgMessageId) await showAnswerOnPhone(done, env);
-  return { ok: true, item: done };
+  return done;
+}
+
+// resolve_question: the owner answered somewhere else (typed in Billion's
+// terminal), so Billion closes the item itself. Nothing goes back into Billion's
+// terminal: it already has the answer. { ok, item } or { error }.
+export async function resolveQuestion({ number, id } = {}, answer, { broadcast, env = process.env } = {}) {
+  const body = typeof answer === 'string' ? answer.replace(/\s+/g, ' ').trim() : '';
+  if (!body) return { error: 'The answer is empty.' };
+  if (body.length > MAX_ANSWER_CHARS) return { error: `Keep the answer under ${MAX_ANSWER_CHARS} characters.` };
+  const item = waitingItems().find(i => (id ? i.id === id : i.n === number));
+  const name = id ? `question ${id}` : `Q${number}`;
+  if (!item) return { error: `There is no ${name}.` };
+  if (item.status === 'dismissed') return { error: `Q${item.n} was dismissed.` };
+  if (item.status === 'answered') return { error: `Q${item.n} was answered already: ${item.answer}` };
+  return { ok: true, item: await markAnswered(item.id, body, 'terminal', { broadcast, env }) };
 }
 
 // The phone's copy of an answered question shows the answer, and loses its buttons.
 async function showAnswerOnPhone(item, env) {
   const { chatId } = telegramSettings(env);
-  const shown = `${questionText(item)}\n\nAnswered${item.answeredVia === 'app' ? ' in app' : ''}: ${item.answer}`;
+  const where = { app: ' in app', terminal: ' in terminal' }[item.answeredVia] || '';
+  const shown = `${questionText(item)}\n\nAnswered${where}: ${item.answer}`;
   const edit = item.tgVoice
     ? call('editMessageCaption', { chat_id: chatId, message_id: item.tgMessageId, caption: shown.slice(0, 1024) }, { env })
     : call('editMessageText', { chat_id: chatId, message_id: item.tgMessageId, text: shown.slice(0, 4096) }, { env });

package/server.js

@@ -30,10 +30,11 @@ import { createSessionFromConfig } from './server/pty.js';
 import { setupWebSocket, broadcast, sessionPayload, broadcastOrphansList, verifyClient, respawnAgent, respawnBoardWorkers } from './server/ws.js';
 import { setupRoutes } from './server/http.js';
 import { startDispatcher, stopDispatcher, boardSettings, releasePushedOrphans } from './server/jobs.js';
-import { orphans, config } from './server/state.js';
+import { orphans, config, CONFIG_DIR } from './server/state.js';
+import { toolsFor } from './server/mcp.js';
 import { sweepMcpConfigs } from './server/agent-mcp.js';
 import { withDefaultPermission, envPermissionMode, PERMISSION_MODES, ENV_PERMISSION_MODE, sessionAgentFromCommand } from './lib/jobs.js';
-import { BILLION_NAME, billionEnabled, billionRuns, billionDir, ensureBillionRepo, refreshCharter, suggestProjectsDir, billionCommand, noClaudeCommand } from './server/billion.js';
+import { BILLION_NAME, billionEnabled, billionRuns, billionDir, ensureBillionRepo, refreshCharter, suggestProjectsDir, billionCommand, noClaudeCommand, changedBoardTools } from './server/billion.js';
 import { commandExists, missingCommandMessage } from './server/command-path.js';
 import { parseCommand } from './lib/helpers.js';
 import { hasClaudeTranscript } from './server/agent-transcripts.js';
@@ -202,11 +203,23 @@ function startBillion() {
     }
   }
   const hasClaude = commandExists('claude', process.env, process.platform, dir);
+  // Without the model lists toolsFor adds: those follow what is installed,
+  // not an upgrade. Only when claude starts, so no start without it uses up
+  // the notice. Best effort, like the charter.
+  const toolsFile = join(CONFIG_DIR, 'billion-tools.json');
+  let changedTools = [];
+  if (hasClaude) {
+    try { changedTools = changedBoardTools(toolsFile, toolsFor({ isBillion: true })); } catch (err) {
+      console.error(`Billion: could not save the board tool definitions to ${toolsFile}:`, err.message);
+    }
+  }
   const command = hasClaude ? billionCommand({
     created,
     hasConversation: !created && hasClaudeTranscript(dir),
     dir,
     projectsHint: suggestProjectsDir(config.repos.map(r => r.path)),
+    changedTools,
+    toolsFile,
   }) : noClaudeCommand();
   const result = createSessionFromConfig({
     sessionId: nextSessionId(), name: BILLION_NAME, color: colorCycler.next(), command,

package/templates/billion/charter.md

@@ -215,6 +215,15 @@ Decide everything yourself except these. Ask the owner first for anything that:
 Going public is not on the list by itself: publishing posts, changing the
 website, launching, emailing people are your call.
 
+**Every question to the owner goes through `notify_owner`.** Anything you
+need the owner to answer, on the list above or not, mid-conversation or not,
+is a `notify_owner` call, with `choices` and `recommended` when it's a pick.
+Saying it only in your terminal doesn't count as asking: it never reaches the
+*Waiting on you* tab or their phone. `tell_owner` is for statements that need
+no answer. When the owner answers a question somewhere other than the tab or
+Telegram (typing in your terminal, say), close it with `resolve_question` and
+their answer, so the tab doesn't hold stale questions.
+
 How to ask: say it in your terminal, and put it under *Waiting on you* in
 `STATE.md` with what, why, and what you recommend, so the owner can answer
 yes or no. Keep working on everything else meanwhile.
@@ -259,6 +268,8 @@ The `agent-007-board` MCP tools:
 - `notify_owner`: puts a question in front of the owner (see **Escalate**).
 - `tell_owner`: a reply or status update to the owner's phone that needs no
   answer; files no *Waiting on you* item (see **Escalate**).
+- `resolve_question`: marks a *Waiting on you* question answered when the
+  owner answered it elsewhere, like in your terminal (see **Escalate**).
 - `answer_permission`: your answer to a worker's permission request (see
   **Approvals**).
 - `read_approval`: a waiting permission request in full, so you can judge