eve-hub 0.6.23 → 0.6.25

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.6.25
+
+### Patch Changes
+
+- 6433096: The Forms guide names the shape by what the content is: a path through three or more parts, events across actors, numbers to compare, and time split into phases (a latency breakdown) as a schedule chart. Never prose steps, an arrow chain, a character drawing or one bar per total.
+
+## 0.6.24
+
+### Patch Changes
+
+- A hosted main keeps its dash and compact schedules: the deploy build and the kit bump write them into a repo that lacks them, and skip a stub whose slot the repo already authors in another source format (dash.mjs, dash.md), which eve would fail as two sources for one slot. Hosted dash has no PR data and compact has nothing to compact until hosted sessions record their last model call; prune stays off.
+
 ## 0.6.23
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.6.23",
+  "version": "0.6.25",
   "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/stubs.mjs

@@ -53,9 +53,13 @@ export const MAIN_KIT_FILES = {
 // the mention gate (the
 // daemon's per-process HUB_AGENT and patched model credential), the tools that
 // remove or restart bots on the hub's disk (a deployment changes its roster by
-// commit; create_agent is that commit, made by the hosted hub), memory (the workspace's files), and main's schedules.
+// commit; create_agent is that commit, made by the hosted hub), memory (the workspace's files), and main's prune schedule (it cleans the hub machine's disk).
+// main's compact and dash schedules stay: off the hub's machine compact finds no session to compact
+// (hosted sessions carry no last-model-call time), and dash has no PR data (its lookup runs `gh`).
 export const DEPLOYED_KIT_FILES = new Set([
   "channels/eve.ts",
+  "schedules/compact.ts",
+  "schedules/dash.ts",
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",
   ...["react", "show", "update_thread", "list_threads", "read_thread", "post_message"].map((t) => `tools/${t}.ts`),

package/sync-kit.mjs

@@ -12,14 +12,18 @@ import {
 const KIT_DIRS = ["tools", "skills", "hooks", "channels", "schedules", "instructions", "memory", "connections"];
 const SUBAGENT = /^(?:subagents\/[^/]+\/)+/;
 const STUB_FILE = new RegExp(`^(${KIT_DIRS.join("|")})/[^/]+\\.ts$`);
+// eve takes one source per slot (dash.ts, dash.mjs and dash.md all claim schedules/dash); a .d.ts, an asset, or a markdown file eve doesn't read there (only schedules and instructions take .md) claims none.
+const SOURCE_FILE = new RegExp(`^(?:(?:${KIT_DIRS.join("|")})/[^/]+\\.[mc]?[tj]s|(?:schedules|instructions)/[^/]+\\.md)$`);
+const isSource = (file) => SOURCE_FILE.test(file.replace(SUBAGENT, "")) && !/\.d\.[mc]?ts$/.test(file);
+const slotOf = (file) => file.replace(/\.[^./]+$/, "");
 const KIT_IMPORT = new RegExp(`^\\s*(?:import|export)\\b(?:[^;"']*?\\bfrom)?\\s*["']eve-hub/((?:${KIT_DIRS.join("|")})/[\\w-]+)["']`, "gm");
 const ALL_STUBS = { ...KIT_FILES, ...MAIN_KIT_FILES };
 const HOST_ONLY = [...Object.keys(ALL_STUBS), ...Object.keys(MEMORY_STUBS)].filter((file) => !DEPLOYED_KIT_FILES.has(file));
 const moduleOf = (file) => (MEMORY_STUBS[file] ? file.slice(0, -3) : kitPath(ALL_STUBS[file][1] ?? file).slice("eve-hub/".length));
 const HOST_ONLY_MODULES = new Set(HOST_ONLY.map(moduleOf));
 
-/** Whether `file` (relative to a bot's agent/ folder, subagents included) is one syncKit reads. */
-export const isKitFile = (file) => file === "instructions.md" || file === MAIN_INSTRUCTIONS || STUB_FILE.test(file.replace(SUBAGENT, ""));
+/** Whether `file` (relative to a bot's agent/ folder, subagents included) is one syncKit reads: a stub, or any source that holds a stub's slot. */
+export const isKitFile = (file) => file === "instructions.md" || file === MAIN_INSTRUCTIONS || isSource(file);
 
 // Every kit module the file imports, from its import and export lines only.
 function kitImports(text) {
@@ -80,7 +84,8 @@ export function syncKit({ bots, modules }) {
         else change.report.push({ bot, file, reason: `imports eve-hub/${host}, which needs the hub's own machine` });
       }
     }
-    for (const file of wanted) if (files[file] === undefined) write(file, content(file));
+    const slots = new Set(Object.keys(files).filter((file) => isSource(file)).map(slotOf));
+    for (const file of wanted) if (!slots.has(slotOf(file))) write(file, content(file));
   }
   return change;
 }
@@ -97,7 +102,7 @@ export function readBotFiles(agentDir, prefix = "") {
   }
   for (const dir of KIT_DIRS) {
     if (!existsSync(join(agentDir, dir))) continue;
-    for (const entry of readdirSync(join(agentDir, dir), { withFileTypes: true })) if (entry.isFile() && entry.name.endsWith(".ts")) read(`${dir}/${entry.name}`);
+    for (const entry of readdirSync(join(agentDir, dir), { withFileTypes: true })) if (entry.isFile() && isKitFile(`${dir}/${entry.name}`)) read(`${dir}/${entry.name}`);
   }
   if (existsSync(join(agentDir, "subagents"))) {
     for (const entry of readdirSync(join(agentDir, "subagents"), { withFileTypes: true })) {

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

@@ -1,4 +1,4 @@
 - **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. There is no `remove_agent`: the roster is `hub.workspace.json`, and a deployment changes it by commit. If nobody on the team covers the work well, ask the human before going on.
 - **Restarts.** There is no `restart_agent` or `restart_hub`: you cannot restart a bot or the hub. A new deployment replaces the running bots.
 - **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.** The build removes the kit's schedules (`dash`, `compact`, `prune`), so no classifier runs, no tick posts, and nothing rewrites track summaries. What you write with `set_summary` and `dash_update` stands until you change it.
+- **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.

package/templates/forms.md

@@ -1,8 +1,10 @@
 
 ## Forms
 
-A form is an interactive figure the app draws from a fenced block with a JSON body. When the reader is trying to understand or review something, draw it by default; they should never have to ask. Pick the shape: a path through parts (`flow`), an order of events (`sequence`), numbers to compare (`chart`), a choice you need from the human (`ask`). Anchor the picture in something they know, e.g. a before form then an after form, each labeled, in one message. Every part of one diagram is the same kind of thing (all hosts, all processes or all functions); say which in the sentence before it, and for a sequence in `unit`. A group is the level that contains them (processes grouped under their host). Plain prose is for what no shape helps. At most one or two forms per message.
+A form is an interactive figure the app draws from a fenced block with a JSON body. Any path through three or more parts, order of events across two or more actors, or numbers to compare is a form, never prose steps, an arrow chain or a character drawing; draw it by default; the reader should never have to ask. Pick the shape: a path through parts (`flow`), an order of events (`sequence`), numbers to compare (`chart`), a choice you need from the human (`ask`). Anchor the picture in something they know, e.g. a before form then an after form, each labeled, in one message. Every part of one diagram is the same kind of thing (all hosts, all processes or all functions); say which in the sentence before it, and for a sequence in `unit`. A group is the level that contains them (processes grouped under their host). Plain prose is for what no shape helps. At most one or two forms per message.
 
+- A code fence is for text the reader will paste, never for a picture: no boxes, arrows, timelines or tables drawn with characters.
+- Pick the shape by what the numbers are. Time split into phases or hops (a latency breakdown, a turn's timeline) is a `schedule` chart: one row per turn or request, one start/end segment per phase, never one `bar` per total. A `bar` compares one number across items.
 - Claim first: a sentence that says what the form shows comes before it. A chart's `title` is its claim.
 - Link a word in your prose to a part with `[word](#id)`. Ids are lowercase slugs (`a-z`, `0-9`, `-`, up to 32 characters), unique in the whole message.
 - Put the explanation of a part in `note` (up to 240 characters), which the human sees when they point at or step to it. Keep labels short.