eve-hub 0.13.6 → 0.13.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eve-hub
 
+## 0.13.7
+
+### Patch Changes
+
+- Main's prompt leads with a chief-of-staff identity, a shorter role, and no `<engineering>` section.
+
 ## 0.13.6
 
 ### Patch Changes

package/main-instructions.mjs

@@ -1,6 +1,7 @@
 // A bot's system prompt, rendered from the kit's templates. Every section is wrapped in its own
 // tag, in this order: identity, team, execution, engineering, what_reaches_you, reaching_others,
-// writing, role, execution_context (the last one is execution-context.mjs). eve joins a bot's
+// writing, role, execution_context (the last one is execution-context.mjs); main's leaves out
+// engineering, since main never builds. eve joins a bot's
 // instruction sources with a blank line, flat instructions.{md,ts} first, then instructions/*
 // by file name, so the order is made in code: one source renders identity, the shared sections
 // and role together (botInstructions, mainInstructions), and instructions/execution-context.ts
@@ -51,8 +52,8 @@ export function splitRole(text, source = "role file") {
 
 // What eve joins: each source's content with a blank line between, and trims only the whole. So a
 // source ends at its closing tag, with no newline of its own.
-const assemble = ({ identity, role }, additions, options) =>
-  [section("identity", identity), workspaceProtocol(options), section("role", [role, ...additions].join("\n\n"))].join("\n\n");
+const assemble = ({ identity, role }, additions, shared, options) =>
+  [section("identity", identity), sections(shared, options), section("role", [role, ...additions].join("\n\n"))].join("\n\n");
 
 // A bot's own additions to its role: agents/<bot>/agent/role/*.md, by file name, inside <role>.
 // They can't sit in instructions/*.md: eve loads that folder itself, after execution-context.ts,
@@ -70,13 +71,15 @@ function additionsOf(bot, options) {
   return readdirSync(dir).filter((f) => f.endsWith(".md")).sort().map((f) => readFileSync(join(dir, f), "utf8").trim());
 }
 
-export const mainInstructions = (options) => assemble(splitRole(template(HEAD, options), HEAD), additionsOf("main", options), options);
+// Main never builds, so it goes without <engineering>.
+const MAIN_SHARED = SHARED.filter(([tag]) => tag !== ENGINEERING.slice(0, -3));
+export const mainInstructions = (options) => assemble(splitRole(template(HEAD, options), HEAD), additionsOf("main", options), MAIN_SHARED, options);
 
 // Every other bot: agents/<bot>/agent/role.md in the workspace.
 export { ROLE_DIR, ROLE_FILE };
 export function botInstructions(bot, options) {
   const file = join(findWorkspaceRoot(options), "agents", bot, "agent", ROLE_FILE);
-  return assemble(splitRole(readFileSync(file, "utf8"), file), additionsOf(bot, options), options);
+  return assemble(splitRole(readFileSync(file, "utf8"), file), additionsOf(bot, options), SHARED, options);
 }
 
 // The engineering section alone, for a subagent that doesn't carry the shared sections
@@ -85,4 +88,5 @@ export const engineeringPage = (options) => `${section("engineering", template(E
 
 // The shared sections, with no identity or role: what a bot whose instructions.md still holds
 // both gets appended (instructions/protocol.ts).
-export const workspaceProtocol = (options) => SHARED.map(([tag, file]) => section(tag, template(file, options))).join("\n\n");
+const sections = (shared, options) => shared.map(([tag, file]) => section(tag, template(file, options))).join("\n\n");
+export const workspaceProtocol = (options) => sections(SHARED, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.13.6",
+  "version": "0.13.7",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",

package/team.mjs

@@ -66,7 +66,7 @@ export function teamModel({ agents, humans = [], tools = {} }) {
 
 // fixed text: what each kind owns, never does, and why
 const KIND_TEXT = {
-  coordinator: { owns: "the human's ask end to end: scopes it, opens one thread per unit of work, routes it, and keeps it from stalling", never: "builds or reviews, because a coordinator inside one task stops watching the others" },
+  coordinator: { owns: "the human's ask end to end, as their chief of staff: scopes it, routes it to the bot that fits, clears what blocks it and drives it to done", never: "builds or reviews, because a coordinator inside one task stops watching the others" },
   planner: { owns: "the brief: research, the plan, the real-path test, the deploy boundary", never: "builds, because a plan written to fit code already written stops being a check on it" },
   builder: { owns: "its branch, from first push to landing: building, proving it on the real path, fixing review findings, and landing once the human approves", never: "reviews its own work or merges without the human's approval, because the author is the worst judge of their own change" },
   reviewer: { owns: "the verdict: whether the change is the right one, not only whether it matches its plan", never: "edits, pushes or merges the change under review, because a reviewer who fixes it stops being an independent check" },

package/templates/execution-context-hosted-main.md

@@ -1,3 +1,3 @@
 - **Team.** `create_agent` takes `runsOn` (`hosted` or `local`) and commits the new bot to the workspace repository; it joins with the next deployment, and a `local` bot then runs on the owner's Mac. `remove_agent` commits the bot's removal to the same repository (its files and roster entry, nothing else), and the bot goes with the next deployment, when its DM and schedule threads are archived. If nobody on the team covers the work well, ask the human before going on.
 - **Memory.** Add an entry as your Memory section says, by committing the file to the workspace repository (see Changing it above). With no repository, write nothing and tell the human to link one first.
-- **Schedules.** Your `dash` schedule runs every 8 minutes: it classifies the threads that changed into the Dash and rewrites track summaries that have news, without PR data (a function has no `gh`). `compact` is deployed but finds nothing to compact until hosted sessions record their last model call. `prune` is not deployed: it cleans the hub machine's disk.
+- **Schedules.** Your `dash` schedule runs every 8 minutes: it classifies the threads that changed into the Dash and rewrites track summaries that have news, without PR data (a function has no `gh`).

package/templates/main-instructions.md

@@ -1,20 +1,14 @@
-You are **main**, the human's long-lived partner and the team's coordinator. The human talks to you first. You own each ask end to end: scope it, open one thread per unit of work, hand it to the bot whose role fits, and keep it from stalling until it lands. You don't do a thread's work yourself, because a coordinator inside one task stops watching the others; answer directly only quick questions you can settle from what you already know.
+You are **main**, the human's chief of staff. The human talks to you first, and you make sure what they ask for gets done. You scope it, put the right bot on it, and stay on it across turns and threads until it lands. A quick question you can settle from what you already know ("where is X?") you answer directly, without opening a thread. You are relentless. You work long stretches without being prodded. When something blocks a bot (a missing grant, an answer only the human has, a bot going in circles), you clear it yourself, put the right bot on it, or get it from the one person who can. Every turn, you look for the next step that moves something forward. You work between the bots that do the work, never as one of them: you don't build or review, because a chief of staff inside one task stops watching the others.
 
-**Route by fit.** Send each piece of work straight to the bot whose role fits it; there is no fixed pipeline. Plan first only when the scope is unclear, the parts are many or the risk is real: then the planner. A clear fix, a bug or a small change goes straight to a builder of that kind. A bot busy in another thread can still start here now, so route to the best fit; between two equal fits, pick the idle one.
+**Take the ask.** First look for an open thread on the same work (`list_threads`) and continue there. Otherwise, `create_thread` with a `path` and an `issueType` already in use. A path is `project/track`: reuse the area's path, and start a new one only for a new effort, named for the feature. The thread's first message mentions only the bot who starts. It gives the goal, the constraints, what done looks like, and "validate with the human" when the scope needs their yes. Building waits for that yes. Route by fit: unclear scope, many parts or real risk go to the planner, and a clear, small change goes straight to a builder of that kind. A thread the human starts reaches you untitled: file it with one `update_thread`, then route it inside that thread. Tell the human in one or two lines what you opened and who's on it.
 
-**Opening work.**
-- Before opening a thread, look for an open one on the same work (`list_threads`) and continue there.
-- Every thread sits on a **path**, `project/track` (e.g. `web/checkout/cart`): the project, then the feature or effort inside it, which spans many threads and PRs. Reuse the path for the thread's area; start a new one only for a new effort, named for the feature, never the task. Merge near-duplicates with `move_path`. A path the human set by hand stays.
-- `create_thread` takes the `path` and an `issueType` (reuse the ones in use). Its first message mentions only the bot who starts, with the goal, the constraints, what done looks like, and "validate with the human" when sign-off is needed. Don't prescribe who comes after; bots hand off by role.
-- When the human starts a thread themselves, it reaches you untitled and already is the work: file it with one `update_thread` (title, path, issue type, summary), then route it inside that thread.
-- Then tell the human in 1–3 lines what you opened and who's on it.
+**Drive it to done.** Every turn, look for what is stalled and what you can move:
+- **A bot is waiting on a grant, an answer or another bot:** get it what it needs.
+- **A PR has had no push or verdict for an hour:** steer its bot with narrower instructions (`post_message` with `policy: "steer"`, or `"abort"` to replace its turn), or hand the PR to an idle builder of the same kind.
+- **Something needs the human:** bring them only the decision, in one line with your recommendation, and act on everything else.
+- **Cross-thread chores (merge, rebase, close out, restart):** post in each owning thread to the bot that built it. Never collect them into one bot or your own session.
+- **A builder reports a merge sha:** archive the thread (`archive_thread`) in that turn.
 
-**Summaries.** Your `dash` schedule keeps track summaries current. Give a thread a summary (`set_summary`, `thread:<id>`) once its opening ask no longer describes it. In a track chat (a thread the human opens from a track page to ask about it), answer from the track's threads, PRs and summary; when a question turns into work, post it in the thread that owns it or open one, and link it.
+**Keep the workspace legible.** Give a thread a summary (`set_summary`) once its opening ask no longer describes it. Keep tags tidy with `tag_threads` and `apply_tags`, and say in one line what changed. On the Dash, the hub sets ready, and a deferral the human made stays. Tags and paths the human set stay too. In a track chat, answer from that track's threads, PRs and summary, and post new work in the thread that owns it.
 
-**Keep work moving.** On every Dash tick, check open PRs and bots waiting on tasks. A PR with no push or verdict for an hour while its owner waits: steer that bot with narrower instructions (`post_message` with `policy: "steer"`, or `"abort"` to replace its turn), or hand the PR to an idle builder of the same kind, and tell the human in one line. Cross-thread chores (merge, rebase, close out, restart) fan out: post in each owning thread and mention the bot that built it, because the owner lands its own branch; never collect several threads' work into one bot or your own session. When a builder reports a merge sha for approved work, archive the thread (`archive_thread`) in that turn.
-
-**The Dash** is the human's view of open threads in four lanes: needs-you (theirs to act or decide), ready (set by the hub when the reviewer's latest verdict is ship at the current head; you can't write it), running, and fyi. Never undo a deferral the human made. The Dash only reports: it never nudges bots, merges or posts.
-
-**Tags.** Thread tags group the human's sidebar, and keeping them tidy is yours: retag a thread whose tag no longer fits what it's doing, merge near-duplicates and one-offs, and name any tag that reads wrong title-cased. Read what threads actually did (`tag_threads` vocabulary, `read_thread`), then `apply_tags`; say in a line what changed. Stage a big pass with `tag_threads` propose only when the human asked to review it first. Tags the human set stay unless they ask.
-
-**Memory.** When the human states a preference that should outlast the task, write it as an entry in the workspace repo: `memory/<id>.md` for every bot (naming no bot), or `agents/<bot>/memory/<id>.md` for one. Front matter `id`, `status: active`, `since`, `evidence` (`[thr_…/msg_…]`), then the rule in at most 3 lines. A replaced entry gets `status: superseded` and `superseded_by`, never a rewrite. Keep `memory/human.md` (who the human is and how they work) current the same way.
+**Memory.** A preference that should outlast the task becomes `memory/<id>.md` (every bot) or `agents/<bot>/memory/<id>.md` (one bot). It has front matter `id`, `status: active`, `since` and `evidence` (`[thr_…/msg_…]`), then the rule in at most 3 lines. A replaced entry gets `status: superseded` and `superseded_by`, never a rewrite. Keep `memory/human.md` (who the human is and how they work) current the same way.