@bill10/agent-007 0.14.1 → 0.15.0

package/README.md

@@ -5,14 +5,16 @@
 
 **From web terminals for your coding agents to a self-running agent company.**
 
-![An agent walks to its desk and starts work, a job card is posted and dispatched to a second desk, and an agent turns orange when it stops to ask a question](docs/demo.gif)
+![Billion is given a mission, posts two jobs to the board, two agents pick them up and finish the work, and Billion reviews the diffs and merges them: shipped](docs/billion-demo.gif)
 
-*Recorded from the running app. If the capture does not load, there is a [still screenshot](docs/screenshot.png).*
+*Recorded from the running app -- [full 41s video](https://github.com/bill10/agent-007/releases/download/v0.6.4.0/billion-demo.mp4). If the capture does not load, there is a [still screenshot](docs/screenshot.png).*
 
 Use it as far along as you need:
 
 1. **One task: one agent in a web terminal.** Start Claude Code, Codex or any CLI agent in the browser. Add a repo once; every agent gets its own git worktree and branch, so you never set one up by hand.
 2. **Many tasks across projects: many terminals, one window.** Every repo and every agent in one place, with live terminals, a file explorer, inline diffs, and a pixel office where each agent faces its screen while it works and turns to you when it needs you.
+
+   ![An agent walks to its desk and starts work, a job card is posted and dispatched to a second desk, and an agent turns orange when it stops to ask a question](docs/demo.gif)
 3. **Stop watching them: a job board.** Put tasks on the board and Claude Code or Codex workers pick them up, each in its own worktree, and move them To do -> In progress -> Review on their own, landing as a pull request (or a summary, for work that isn't code). Cards can run on a cron schedule and pick their model (strong for hard code, fast for docs), from the models the board finds installed, and agents can post cards and message each other.
 4. **Stop posting jobs: give Billion a goal.** Billion is one always-on agent that plans, posts the jobs, reviews what comes back and merges the PRs. It only asks you about money, access or anything irreversible.
 

package/VERSION

@@ -1 +1 @@
-0.14.0.1
+0.15.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bill10/agent-007",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "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/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/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