@volter/supercode-orchestrator 0.5.210 → 0.5.212

package/mcp/mount.mjs

@@ -24,13 +24,19 @@ import { SOCKET_ENV, socketPathFor } from './server.mjs';
 import { mcpServers } from '../hermes-home.mjs';
 import { KANBAN_ENV } from '../hermes-cli.mjs';
 import { installedAgentRecord } from '../installed-apps.mjs';
+import { supercodeHome } from '@volter/teams/home';
 
 export { MCP_DOORS, doorFor } from '@volter/supercode-harness-sdk/mcp-doors';
 
-/** The stdio server this module mounts. */
+/** The stdio server `supercode orchestrator mcp-server` runs (the mount names that door, never this path). */
 export const SERVER_PATH = resolve(dirname(fileURLToPath(import.meta.url)), 'server.mjs');
-/** The orchestrator's CLI, whose `apps mcp` runs `rh2 mcp` as an installed agent. */
-const ORCHESTRATOR_BIN = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/orchestrator.mjs');
+/** The machine's stable `supercode` (the source pin's shim in the supercode home, else the one on PATH), which runs
+ * every program a session mounts (`orchestrator mcp-server`, `orchestrator apps mcp`): a config that names it names no
+ * release, so the pin that retires a tree leaves it working. */
+function stableSupercode() {
+  const shim = join(supercodeHome(), 'bin', process.platform === 'win32' ? 'supercode.cmd' : 'supercode');
+  return existsSync(shim) ? shim : 'supercode';
+}
 /** The MCP server an agent with an installed rh2-agent gets: `rh2 mcp` as that agent (its own name, so the user's own
  * `rh2` server, whatever it holds, is neither replaced nor relied on). */
 export const RH2_AGENT_SERVER = 'rh2-agent';
@@ -40,7 +46,7 @@ export const RH2_AGENT_SERVER = 'rh2-agent';
  * Teams id): a record is found by that id alone, so an agent sharing another's name is never mounted with its record. */
 function rh2AgentServer(root, agentId, program) {
   if (!installedAgentRecord(root, agentId)) return null;
-  return { command: program, args: [ORCHESTRATOR_BIN, 'apps', 'mcp', 'rh2-agent', '--root', root, '--agent', agentId] };
+  return { command: stableSupercode(), args: ['orchestrator', 'apps', 'mcp', 'rh2-agent', '--root', root, '--agent', agentId, '--node', program] };
 }
 
 const slug = (surfaceKey) => (surfaceKey ? String(surfaceKey).replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'session' : 'session');
@@ -55,13 +61,12 @@ const slug = (surfaceKey) => (surfaceKey ? String(surfaceKey).replace(/[^A-Za-z0
  * @param {string|null} o.surfaceKey  the surface this session is bound to
  * @param {object|undefined} o.launch the launch the loop resolved, if any
  * @param {string} [o.socketPath]   defaults to `<root>/orchestrator.sock`
- * @param {string} [o.serverPath]   defaults to this package's `mcp/server.mjs`
- * @param {string} [o.program]      the interpreter, defaults to this node
+ * @param {string} [o.program]      the node the server runs with, defaults to this node
  * @param {string|null} [o.agentId] the Teams id of the agent whose own session this is, whose installed rh2-agent is
  *                                  mounted beside; null for a worker acting for an agent
  * @returns {{door: string, ran: string, launch: object|undefined, mcp_servers: object[]|null, path: string|null}}
  */
-export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null, launch, socketPath, serverPath = SERVER_PATH, program = process.execPath, vault = new Map(), task = null, agentId = null }) {
+export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null, launch, socketPath, program = process.execPath, vault = new Map(), task = null, agentId = null }) {
   const door = doorFor(harness);
   // the profile's own servers (`.mcp.json`, the workers' form; docs/plans/hermes-compat.md row 4), mounted
   // beside this one through the same door, `${VAR}` resolved from the profile's vault
@@ -81,6 +86,9 @@ export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null
   // board's tools for it (docs/plans/hermes-compat.md row 14)
   const sessionEnv = { ...env, ...(surfaceKey ? { [ORCH_ENV.surface]: surfaceKey } : {}), ...(task ?? {}) };
 
+  // the server through the stable supercode, never this release's server.mjs: a pin that retires this tree leaves the
+  // session's next server start (a resume, a reconnect) working
+  const server = { command: stableSupercode(), args: ['orchestrator', 'mcp-server', '--node', program] };
   switch (door) {
     case 'flag': {
       if (!launch) {
@@ -88,14 +96,14 @@ export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null
       }
       const file = join(home, `mcp-orchestrator-${slug(surfaceKey)}.json`);
       mkdirSync(home, { recursive: true });
-      writeMcpConfigFile(file, { ...own, [SERVER_NAME]: { command: program, args: [serverPath], env: sessionEnv } });
+      writeMcpConfigFile(file, { ...own, [SERVER_NAME]: { ...server, env: sessionEnv } });
       return { door, ran: `wrote ${file} and passed --mcp-config`, launch: withMcpConfigFlag(launch, file), mcp_servers: null, path: file };
     }
 
     case 'toml': {
       const file = join(home, 'config.toml');
       mkdirSync(home, { recursive: true });
-      const block = tomlBlock(program, serverPath, env);
+      const block = tomlBlock(server, env);
       let text = upsertTomlBlock(existsSync(file) ? readFileSync(file, 'utf8') : '', block, SERVER_NAME);
       const written = ownNames(home);
       for (const name of written) if (!(name in own)) text = removeTomlBlock(text, name);
@@ -115,7 +123,7 @@ export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null
       for (const name of ownNames(home)) if (!(name in own)) delete config.mcp[name];
       for (const [name, server] of Object.entries(own)) config.mcp[name] = opencodeEntry(server);
       recordOwnNames(home, Object.keys(own));
-      config.mcp[SERVER_NAME] = opencodeEntry({ command: program, args: [serverPath], env });
+      config.mcp[SERVER_NAME] = opencodeEntry({ ...server, env });
       writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
       return { door, ran: `wrote mcp.${SERVER_NAME} into ${file}`, launch, mcp_servers: null, path: file };
     }
@@ -131,7 +139,7 @@ export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null
         launch,
         mcp_servers: [
           ...Object.entries(own).filter(([, server]) => server.command).map(([name, server]) => acpEntry(name, server)),
-          acpEntry(SERVER_NAME, { command: program, args: [serverPath], env: sessionEnv }),
+          acpEntry(SERVER_NAME, { ...server, env: sessionEnv }),
         ],
         path: null,
       };
@@ -139,11 +147,11 @@ export function mountOrchestratorMcp({ root, profile, harness, surfaceKey = null
 }
 
 /** The orchestrator's own `[mcp_servers.orchestrator]` block. */
-function tomlBlock(program, serverPath, env) {
+function tomlBlock({ command, args }, env) {
   const lines = [
     `[mcp_servers.${SERVER_NAME}]`,
-    `command = ${tomlString(program)}`,
-    `args = [${tomlString(serverPath)}]`,
+    `command = ${tomlString(command)}`,
+    `args = [${args.map(tomlString).join(', ')}]`,
   ];
   for (const [k, v] of Object.entries(env)) lines.push(`env.${k} = ${tomlString(v)}`);
   // The per-session half rides codex's own env allowlist: the server is a child

package/orchestration.mjs

@@ -28,6 +28,7 @@ import { fileURLToPath } from 'node:url';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 import { emptyRuntime, persistedView } from './ir.mjs';
 import { lockedNative } from './source-lock.mjs';
+import { SESSION_READ_REQUEST_UNITS, stringifySessionWire } from '@volter/supercode-teams/session-read-client';
 
 const here = dirname(fileURLToPath(import.meta.url));
 
@@ -150,7 +151,7 @@ export async function load(root) {
   const { orchestration, vault_keys } = await through((d) => d.orchestrationLoad({ root }));
   let vault = readVault(orchestration);
   if (vault_keys.some((k) => !vault.has(k))) {
-    await through((d) => d.orchestrationSave({ root, orchestration, preserve_workflow: true }));
+    await save(stateOf(orchestration), root);
     vault = readVault(orchestration);
     const missing = vault_keys.filter((k) => !vault.has(k));
     if (missing.length) throw new Error(`${root}: ${missing.join(', ')} referenced but not in .env after normalization`);
@@ -172,10 +173,36 @@ export async function read(root) {
  * written as the home last held it, or left out when it held none, and none refuses the rest of the save.
  */
 export async function save(state, root = state.root) {
-  const saved = await through((d) => d.orchestrationSave({ root, orchestration: persistedView(state), preserve_workflow: true }));
+  const params = boundedRuntimeSave(state, root);
+  const saved = await through((d) => d.orchestrationSave(params));
+  // Apply retention in memory only after the owning door accepted it.
+  for (const [name, profile] of Object.entries(params.orchestration.profiles)) state.profiles[name].fires = profile.fires;
   return { rejected: Array.isArray(saved?.rejected) ? saved.rejected : [] };
 }
 
+// A per-profile row count cannot bound the whole home's request. Keep active fires and all configuration, and
+// remove the oldest terminal history across profiles until the actual native wire value fits, with envelope room.
+export function boundedRuntimeSave(state, root = state.root) {
+  const orchestration = { ...persistedView(state), profiles: Object.fromEntries(Object.entries(state.profiles).map(([name, profile]) => [name, { ...profile, fires: [...profile.fires] }])) };
+  const params = { root, orchestration, preserve_workflow: true };
+  const budget = SESSION_READ_REQUEST_UNITS - 16 * 1024;
+  let units = Buffer.byteLength(stringifySessionWire(params));
+  if (units <= budget) return params;
+  const terminal = Object.entries(orchestration.profiles).flatMap(([name, profile]) => profile.fires
+    .filter(fire => !['claimed', 'running'].includes(fire.status)).map(fire => ({ name, fire })));
+  terminal.sort((a, b) => String(a.fire.claimed_at ?? '').localeCompare(String(b.fire.claimed_at ?? '')) || String(a.fire.id).localeCompare(String(b.fire.id)));
+  const drop = new Set();
+  for (const { fire } of terminal) {
+    if (units <= budget) break;
+    drop.add(fire);
+    units -= Buffer.byteLength(stringifySessionWire(fire)) + 1;
+  }
+  for (const profile of Object.values(orchestration.profiles)) profile.fires = profile.fires.filter(fire => !drop.has(fire));
+  const actual = Buffer.byteLength(stringifySessionWire(params));
+  if (actual > budget) throw new Error(`orchestrator runtime save needs ${actual} bytes after terminal-history retention (limit ${budget}); configuration and active jobs were preserved; no execution was started`);
+  return params;
+}
+
 /** Another harness's home as a state value (no secret value; `vault_keys` names the `.env` keys it would need). */
 export async function compile(from, home) {
   const { orchestration, vault_keys } = await through((d) => d.orchestrationCompile({ from, home }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.210",
+  "version": "0.5.212",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {
@@ -32,10 +32,10 @@
     "check-types": "node scripts/generate-types.mjs --check"
   },
   "dependencies": {
-    "@volter/supercode-teams": "^0.3.346",
+    "@volter/supercode-teams": "^0.3.347",
     "@volter/supercode-terminal": "^0.3.10",
     "@volter/supercode-harness-sdk": "^0.3.104",
-    "@volter/teams": "0.2.98",
+    "@volter/teams": "0.2.99",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },
@@ -61,6 +61,5 @@
     "board",
     "apply",
     "README.md"
-  ],
-  "gitHead": "b2585dc5c6b40d48be96fd3c4148f2c53d7a7ef2"
+  ]
 }