@volter/supercode-orchestrator 0.5.215 → 0.5.217

package/loop.mjs

@@ -10,14 +10,14 @@ import { parseSessionWire, stringifySessionWire } from '@volter/supercode-teams/
 import { step, leaseId } from './reducer.mjs';
 import * as events from './events.mjs';
 import { read, save, retainWorld, releaseWorld, refreshVault } from './orchestration.mjs';
-import { INSTRUCTION_ARGUMENTS, NAME_ARGUMENTS, activationEnv, activationCwd, workerCwd, declareWorkerFolder, declareWorkerHome, approvalPolicy, sandboxArguments, limitArguments, materializePersona, materializeSkills, modelArguments, turnCounter, userHomeArguments, userHomePersona } from './activation.mjs';
+import { INSTRUCTION_ARGUMENTS, NAME_ARGUMENTS, activationEnv, activationCwd, workerCwd, declareWorkerFolder, declareWorkerHome, approvalPolicy, approvalsReviewer, mainApprovalArguments, modeArguments, limitArguments, materializePersona, materializeSkills, modelArguments, turnCounter, userHomeArguments, userHomePersona } from './activation.mjs';
 import { workerRoute, codexPaneRoute } from './worker-route.mjs';
 import { projectCodexPaneResume } from './codex-pane-resume.mjs';
 import { hermesAccess, hermesApproval, untrustedServerVerdict, hermesToolEnv, memorySnapshot, mirrorSession, mirrorState, recordIncident, sealMirror } from './hermes-cli.mjs';
 import { hermesSessionKey, homeChannel } from './ir.mjs';
 import { surfaceKeyString } from './ir.mjs';
 import { BREAKER_FAILURES, BREAKER_MINUTES, MAX_ATTEMPTS, historyRetention, jobGate } from './cron.mjs';
-import { startWebhookListener } from './webhook.mjs';
+import { startWebhookListener, WebhookRefusal, findSubscription } from './webhook.mjs';
 import { startBridge } from './mcp/bridge.mjs';
 import { socketPathFor } from './mcp/server.mjs';
 import { mountOrchestratorMcp } from './mcp/mount.mjs';
@@ -29,7 +29,9 @@ import { agentScope,localProfileAgent,localAgentRecord,localAgentSessions,localF
 import { materializeAgentHome } from './agent-home.mjs';
 import { knowLocalMachine } from './board/dispatch.mjs';
 import { execFile } from 'node:child_process';
+import { supercodeInvocation } from '@volter/supercode-harness-sdk/supercode-program';
 import { promisify } from 'node:util';
+import { randomUUID } from 'node:crypto';
 
 /**
  * Where a worker keeps its transcripts inside its config home (`<profile>/<harness>`), as discovery and
@@ -80,6 +82,9 @@ export class Orchestrator {
     this.log = log;
     this.runtimes = new Map(); // leaseId -> ManagedRuntime
     this.queue = Promise.resolve();
+    this.internalDispatches = new Set();
+    this.internalFailures = [];
+    this.webhookAdmissions = new Map();
     this.effectLog = [];
     this.support = null; // memoized `supportReport()`: the registry does not move under a run
   }
@@ -90,7 +95,9 @@ export class Orchestrator {
     for (const [platform, adapter] of Object.entries(this.adapters)) await this.connectAdapter(platform, adapter);
     this.webhooks = await startWebhookListener({
       state: this.state, vault: this.vault, port: webhookPort(this.state),
-      dispatch: (event) => this.dispatchLogged(event), clock: () => this.clock(), log: this.log,
+      // The listener owns admission, including complete bodies still verifying
+      // when stop begins. Join their real processing result before HTTP success.
+      dispatch: (event) => this.dispatchWebhook(event), clock: () => this.clock(), log: this.log,
     });
     this.bridge = await startBridge({ orch: this, socketPath: socketPathFor(this.state.root), log: this.log });
     // the queue already logs a failed event; a voided dispatch must not also
@@ -106,27 +113,34 @@ export class Orchestrator {
    * daemon's own doors keep serving, and the connect is tried again until it holds or the daemon stops.
    */
   async connectAdapter(platform, adapter) {
-    let status;
+    if (this.stopping) return;
+    let joined;
+    const pending = new Promise(resolve => { joined = resolve; });
+    (this.adapterConnects ??= new Set()).add(pending);
     try {
-      status = await adapter.connect((msg) => this.dispatchLogged(events.inbound({ ...msg, at: msg.at ?? this.clock() })));
-      if (status?.state === 'down' && status.configured === false) {
-        // not set up (a missing package or credential): no retry can fix it
-        this.log('error', `${platform}: not configured, not retried: ${status.error}`);
-        await this.dispatchLogged(events.adapterStatus({ platform, state: 'down', error: status.error, configured: false, at: this.clock() }));
+      let status;
+      try {
+        status = await adapter.connect((msg) => this.dispatchLogged(events.inbound({ ...msg, at: msg.at ?? this.clock() })));
+        if (status?.state === 'down' && status.configured === false) {
+          // not set up (a missing package or credential): no retry can fix it
+          this.log('error', `${platform}: not configured, not retried: ${status.error}`);
+          await this.dispatchLogged(events.adapterStatus({ platform, state: 'down', error: status.error, configured: false, at: this.clock() }));
+          return;
+        }
+      } catch (error) {
+        this.log('error', `${platform}: connect failed, retrying in ${ADAPTER_RETRY_MS / 1000}s: ${error instanceof Error ? error.message : String(error)}`);
+        await this.dispatchLogged(events.adapterStatus({ platform, state: 'down', error: error instanceof Error ? error.message : String(error), at: this.clock() }));
+        if (this.stopping) return;
+        this.adapterRetries ??= new Map();
+        const timer = setTimeout(() => { this.adapterRetries?.delete(platform); void this.connectAdapter(platform, adapter); }, ADAPTER_RETRY_MS);
+        timer.unref?.();
+        this.adapterRetries.set(platform, timer);
         return;
       }
-    } catch (error) {
-      this.log('error', `${platform}: connect failed, retrying in ${ADAPTER_RETRY_MS / 1000}s: ${error instanceof Error ? error.message : String(error)}`);
-      await this.dispatchLogged(events.adapterStatus({ platform, state: 'down', error: error instanceof Error ? error.message : String(error), at: this.clock() }));
-      this.adapterRetries ??= new Map();
-      const timer = setTimeout(() => { this.adapterRetries?.delete(platform); void this.connectAdapter(platform, adapter); }, ADAPTER_RETRY_MS);
-      timer.unref?.();
-      this.adapterRetries.set(platform, timer);
-      return;
-    }
-    // connected: recording that is the queue's (a failed save is logged there),
-    // never a reason to connect the same adapter again
-    await this.dispatchLogged(events.adapterStatus({ platform, state: status?.state ?? 'up', at: this.clock() }));
+      // connected: recording that is the queue's (a failed save is logged there),
+      // never a reason to connect the same adapter again
+      await this.dispatchLogged(events.adapterStatus({ platform, state: status?.state ?? 'up', at: this.clock() }));
+    } finally { this.adapterConnects.delete(pending); joined(); }
   }
 
   /** The port the webhook listener bound (0 in config means "any free port"). */
@@ -231,27 +245,111 @@ export class Orchestrator {
     }
   }
 
-  async stop() {
+  stop() {
+    return this.stopPromise ??= this.stopOwned();
+  }
+
+  async stopOwned() {
+    this.stopping = true;
+    this.stopErrors = [];
+    const attempt = async (name, work) => {
+      try { await work(); }
+      catch (error) { this.stopErrors.push(new Error(`${name}: ${error.message}`, { cause: error })); }
+    };
     if (this.timer) { clearInterval(this.timer); this.timer = null; }
-    // Before any runtime closes: each binding records the runtime to resume (§4.7), while adapters can still deliver.
-    await this.dispatch(events.stopping(this.clock())).catch((error) => this.log('error', `stopping: ${error.message}`));
     for (const timer of this.adapterRetries?.values() ?? []) clearTimeout(timer);
     this.adapterRetries?.clear();
-    if (this.webhooks) { await this.webhooks.close(); this.webhooks = null; }
-    if (this.bridge) { await this.bridge.close(); this.bridge = null; }
+    // Unsent worker input has no positive HTTP receipt. Refuse it before
+    // joining handlers; a queued turn cannot hold stop waiting for a model.
+    for (const admission of this.webhookAdmissions.values()) if (!admission.sending) admission.finish(new WebhookRefusal('orchestrator is stopping; retry the webhook'));
     this.gateAbort?.abort();
-    await this.drainHosted();
-    for (const rt of this.runtimes.values()) { try { await rt.close(); } catch { /* already gone */ } }
+    // close() seals ingress synchronously, before any connect/cleanup wait.
+    // Already-admitted bodies retain dispatch authority through verification;
+    // their handlers join the queue before its stopping event below.
+    const webhooksClosed = this.webhooks ? attempt('webhooks', () => this.webhooks.close()) : Promise.resolve();
+    await Promise.allSettled([...(this.adapterConnects ?? [])]);
+    await webhooksClosed;
+    this.webhooks = null;
+    if (this.bridge) { await attempt('bridge', () => this.bridge.close()); this.bridge = null; }
+    await attempt('hosted jobs', () => this.drainHosted());
+    await attempt('internal completions', () => this.drainInternal());
+    // Join admitted work and record the resumable binding before closing runtimes.
+    await attempt('stopping', () => this.dispatch(events.stopping(this.clock())));
+    for (const rt of new Set([...this.runtimes.values(), ...this.retired.values()])) await attempt('runtime', () => rt.close());
     this.runtimes.clear();
-    for (const adapter of Object.values(this.adapters)) await adapter.close?.();
-    releaseWorld();
+    this.retired.clear();
+    for (const adapter of Object.values(this.adapters)) await attempt('adapter', () => adapter.close?.());
+    await attempt('World reference', () => releaseWorld());
+    if (this.stopErrors.length) throw new AggregateError(this.stopErrors, this.stopErrors.map(error => error.message).join('; '));
   }
 
   /** Events are applied one at a time, in arrival order; effects run before the next event. */
   dispatch(event) {
-    const run = this.queue.then(() => this.apply(event));
+    const frame = { children: [] };
+    const run = this.queue.then(async () => {
+      this.applying = frame;
+      try { return await this.apply(event); }
+      finally { this.applying = null; }
+    });
     this.queue = run.catch((error) => this.log('error', `dispatch: ${error.message}`));
-    return run;
+    // The queue serializes reducer applications, not these joins: a child
+    // must be able to run after its parent's apply without waiting on itself.
+    const joined = async (result, failures = []) => {
+      const children = await Promise.allSettled(frame.children);
+      const errors = [...failures, ...children.filter(row => row.status === 'rejected').map(row => row.reason)];
+      if (errors.length) throw new AggregateError(errors, errors.map(error => String(error?.message ?? error)).join('; '));
+      return result;
+    };
+    return run.then(result => joined(result), error => joined(null, [error]));
+  }
+
+  /** HTTP success for worker input means handoff, never just an in-memory queue. */
+  dispatchWebhook(event) {
+    if (this.stopping) return Promise.reject(new WebhookRefusal('orchestrator is stopping; retry the webhook'));
+    if (!event.verified) return this.dispatch(event);
+    const found = findSubscription(this.state, event.name);
+    if (!found?.profile.worker || found.sub.residue?.deliver_only === true) return this.dispatch(event);
+    const previous = event.delivery_id && [...this.webhookAdmissions.values()].find(row => row.name === event.name && row.delivery_id === event.delivery_id);
+    if (previous) return previous.completion;
+    const id = randomUUID();
+    let settle;
+    const admission = { name: event.name, delivery_id: event.delivery_id, result: new Promise(resolve => { settle = resolve; }) };
+    admission.finish = error => {
+      if (admission.outcome) return;
+      admission.outcome = { error };
+      settle(admission.outcome);
+    };
+    this.webhookAdmissions.set(id, admission);
+    admission.completion = (async () => {
+      try {
+        await this.dispatch({ ...event, admission_id: id });
+        if (!admission.awaitingInput) admission.finish(null);
+        const { error } = await admission.result;
+        if (error) throw error;
+      } catch (error) {
+        // A retryable refusal must not leave an in-memory dedup success for
+        // input that was never handed off. Concurrent retries join above.
+        try {
+          await this.dispatch({ type: 'webhook_refused', name: event.name, delivery_id: event.delivery_id, admission_id: id,
+            profile: admission.profile, keyString: admission.keyString, handed: Boolean(admission.outcome && !admission.outcome.error), stopping: Boolean(this.stopping), at: this.clock() });
+        } catch (cleanupError) { throw new AggregateError([error, cleanupError], 'webhook refusal cleanup failed'); }
+        throw error;
+      } finally { this.webhookAdmissions.delete(id); }
+    })();
+    return admission.completion;
+  }
+
+  /** Drain descendants to a stable queue tail, then fence later worker callbacks. */
+  async drainInternal() {
+    for (;;) {
+      const tail = this.queue;
+      await Promise.allSettled([tail, ...this.internalDispatches]);
+      if (tail === this.queue && !this.internalDispatches.size) {
+        this.internalClosed = true;
+        break;
+      }
+    }
+    if (this.internalFailures.length) throw new AggregateError(this.internalFailures, 'internal completion failed');
   }
 
   /**
@@ -260,19 +358,40 @@ export class Orchestrator {
    * event currently being applied, i.e. on itself.
    */
   enqueue(event) {
-    void this.dispatchLogged(event);
+    if (this.internalClosed) return;
+    const pending = this.dispatch(event);
+    this.applying?.children.push(pending);
+    this.internalDispatches.add(pending);
+    void pending.then(() => this.internalDispatches.delete(pending), error => {
+      this.internalFailures.push(error);
+      this.internalDispatches.delete(pending);
+    });
   }
 
   /**
    * `dispatch` for a caller that drops the promise (a timer, an adapter's
-   * inbound callback, the webhook listener). The queue already logged the
+   * inbound callback). Webhooks retain their dispatch result for HTTP admission.
+   * The queue already logged the
    * failure; an unhandled rejection is fatal to Node and stopped the daemon.
    */
   dispatchLogged(event) {
+    if (this.stopping) return Promise.resolve();
     return this.dispatch(event).catch(() => undefined);
   }
 
   async apply(event) {
+    if (event.type === 'webhook' && this.webhookAdmissions.get(event.admission_id)?.outcome?.error) return [];
+    if (event.type === 'worker' && ['error', 'ended'].includes(event.ev.kind)) {
+      const binding = this.state.profiles[event.profile]?.bindings?.[event.keyString];
+      const current = this.state.runtime?.leases?.[leaseId(event.profile, event.keyString)]?.runtime_id ?? binding?.residue?.runtime_id ?? null;
+      if (!event.runtime_id || event.runtime_id === current) {
+        for (const admission of this.webhookAdmissions.values()) {
+          if (admission.profile === event.profile && admission.keyString === event.keyString) {
+            admission.finish(new Error(`webhook worker ended before handoff: ${event.ev.message ?? event.ev.reason ?? 'worker ended'}`));
+          }
+        }
+      }
+    }
     if(event.type==='inbound'&&!event.is_me) {
       // An adapter's display name or supplied principal never proves identity.
       const observation=`${event.key.platform}:${event.sender}`;
@@ -293,11 +412,29 @@ export class Orchestrator {
       if (index === firstSave) continue;
       await this.perform(effect);
     }
+    // Expiry/reset/end can remove a queued input before its handoff. Its HTTP
+    // owner must receive refusal rather than wait on a queue that no longer exists.
+    for (const [id, admission] of this.webhookAdmissions) {
+      if (!admission.awaitingInput || admission.outcome || admission.sending) continue;
+      const lid = leaseId(admission.profile, admission.keyString);
+      const rt = this.state.runtime;
+      if (rt?.turns?.[lid]?.webhook_input_id !== id && !rt?.queues?.[lid]?.some(row => row.webhook_input_id === id)) {
+        admission.finish(new WebhookRefusal('worker input ended before handoff; retry the webhook'));
+      }
+    }
     return effects;
   }
 
   async perform(effect) {
     switch (effect.type) {
+      case 'webhook_input': {
+        const admission = this.webhookAdmissions.get(effect.admission_id);
+        if (admission) {
+          Object.assign(admission, { awaitingInput: true, profile: effect.profile, keyString: effect.keyString });
+          if (effect.refusal) admission.finish(new WebhookRefusal(effect.refusal));
+        }
+        return;
+      }
       case 'execute_job': return this.executeHostedJob(effect);
       case 'run_gate': return this.runGate(effect);
       case 'runtime_start': return this.startRuntime(effect);
@@ -382,7 +519,8 @@ export class Orchestrator {
     const args = ['open', '--new', program, '--detach', '--window=true', '--on', machine, '--key', `cron-${fire.id}`, '--input', job.prompt ?? ''];
     if (job.workdir && job.workdir.startsWith('/')) args.push('--cwd', job.workdir);
     if (job.model) args.push('--', '--model', job.model);
-    const { stdout } = await promisify(execFile)(process.env.SUPERCODE_BIN || 'supercode', args, { timeout: 180_000, maxBuffer: 4 * 1024 * 1024 });
+    const selected = supercodeInvocation(process.env.SUPERCODE_BIN || 'supercode', args);
+    const { stdout } = await promisify(execFile)(selected.program, selected.arguments, { timeout: 180_000, maxBuffer: 4 * 1024 * 1024 });
     const pane = /"pane"\s*:\s*"([^"]+)"/.exec(stdout)?.[1] ?? null;
     return { accepted: true, output: `Fire ${fire.id} of ${job.id} launched on ${machine}${pane ? ` in pane ${pane}` : ''}.`, machine, pane };
   }
@@ -415,7 +553,7 @@ export class Orchestrator {
       return { monitor, script };
     })()
       .catch((error) => ({ script: { ok: false, output: `Script execution failed: ${error.message}` } }))
-      .then((answer) => (signal.aborted ? undefined : this.dispatchLogged(events.gateResult({ profile: name, fire_id, at: this.clock(), ...answer }))))
+      .then((answer) => { if (!signal.aborted) this.enqueue(events.gateResult({ profile: name, fire_id, at: this.clock(), ...answer })); })
       .finally(() => this.hostedTasks.delete(task));
     this.hostedTasks.add(task);
   }
@@ -494,8 +632,8 @@ export class Orchestrator {
       if (resume_runtime_id) resume_runtime_id = await this.continueFromHermes(profile, keyString, worker, resume_runtime_id, cwd,agentHome);
       // read before the runtime exists: a runtime emits from the moment it is made
       steer = Boolean((await this.descriptorFor(worker.harness).catch(() => null))?.runtime?.capabilities?.steer);
-      const policy = approvalPolicy(profile, worker.harness);
-      const params = { harness: worker.harness, cwd, launch: mount.launch, ...(mount.mcp_servers ? { mcp_servers: mount.mcp_servers } : {}), ...(policy ? { approval_policy: policy } : {}) };
+      const policy = approvalPolicy(profile, worker.harness), reviewer = approvalsReviewer(profile, worker.harness);
+      const params = { harness: worker.harness, cwd, launch: mount.launch, ...(mount.mcp_servers ? { mcp_servers: mount.mcp_servers } : {}), ...(policy ? { approval_policy: policy } : {}), ...(reviewer ? { approvals_reviewer: reviewer } : {}) };
       if (resume_runtime_id && (await this.descriptorFor(worker.harness).catch(() => null))?.runtime?.capabilities?.resume_session) {
         try {
           runtime = await this.client.resumeManagedRuntime({ ...params, runtime_id: resume_runtime_id });
@@ -581,9 +719,12 @@ export class Orchestrator {
     const instructions = agentPreamble(agent, { main: true,
       previous: localAgentSessions(this.state.root, scope.org, agent.identity.id) });
     const arguments_ = [...route.args, ...INSTRUCTION_ARGUMENTS.codex(instructions)];
+    // The profile's mode, on a resume too: an approvals-on main asks a person (`on-request`, reviewer `user`), an
+    // approvals-off main gets the auto-reviewer again (a resume's recorded mode gives way to it: teams/mail/agents.mjs
+    // `resume`).
+    arguments_.push(...mainApprovalArguments(profile));
     if (resume === null) {
-      arguments_.push(...modelArguments({ ...worker, model: route.model }), '--ask-for-approval', approvalPolicy(profile, 'codex'));
-      arguments_.push(...sandboxArguments(profile, 'codex'));
+      arguments_.push(...modelArguments({ ...worker, model: route.model }));
       if (worker.reasoning_effort) arguments_.push('-c', `model_reasoning_effort=${JSON.stringify(worker.reasoning_effort)}`);
     }
     declareWorkerHome({ harness: 'codex', env, cwd: folder, log: (level, text) => this.log(level, text) });
@@ -712,7 +853,7 @@ export class Orchestrator {
   async resolveLaunch(profile, worker, env, routeArgs = []) {
     if (this.launchFor) {
       const override = this.launchFor(profile, worker, env);
-      if (override) return { ...override, arguments: [...(override.arguments ?? []), ...modelArguments(worker), ...routeArgs, ...sandboxArguments(profile, worker.harness), ...limitArguments(profile, worker, this.log)] };
+      if (override) return { ...override, arguments: [...(override.arguments ?? []), ...modelArguments(worker), ...routeArgs, ...modeArguments(profile, worker.harness), ...limitArguments(profile, worker, this.log)] };
     }
     const base = (await this.descriptorFor(worker.harness))?.runtime?.default_launch;
     if (!base) {
@@ -720,7 +861,7 @@ export class Orchestrator {
       if (worker.model) throw new Error(`${worker.harness} publishes no launch to carry model ${worker.model}`);
       return undefined;
     }
-    return { program: base.program, arguments: [...(base.arguments ?? []), ...modelArguments(worker), ...routeArgs, ...sandboxArguments(profile, worker.harness), ...limitArguments(profile, worker, this.log)], env: { ...(base.env ?? {}), ...env } };
+    return { program: base.program, arguments: [...(base.arguments ?? []), ...modelArguments(worker), ...routeArgs, ...modeArguments(profile, worker.harness), ...limitArguments(profile, worker, this.log)], env: { ...(base.env ?? {}), ...env } };
   }
 
   /**
@@ -904,9 +1045,13 @@ export class Orchestrator {
     } catch (error) { this.log('warn', `transfer history unread: ${error.message}`); return ''; }
   }
 
-  async sendInput({ profile, keyString, text, context_from = null, skills = [], job_id = null, history = null }) {
+  async sendInput({ profile, keyString, text, context_from = null, skills = [], job_id = null, history = null, webhook_input_id = null }) {
+    const admission = webhook_input_id ? this.webhookAdmissions.get(webhook_input_id) : null;
+    // Shutdown refused this unsent request (or its handler already failed).
+    // It must not be delivered later by a queued started/final completion.
+    if (webhook_input_id && (!admission || admission.outcome?.error)) return;
     const runtime = this.runtimes.get(leaseId(profile, keyString));
-    if (!runtime) { this.log('warn', `send_input with no runtime for ${keyString}`); return; }
+    if (!runtime) { admission?.finish(new Error(`webhook input has no runtime for ${keyString}`)); this.log('warn', `send_input with no runtime for ${keyString}`); return; }
     const owner = this.state.profiles[profile];
     const dir = owner?.dir;
     let input = context_from && dir ? contextFromPrefix(dir, job_id, context_from) + text : text;
@@ -914,19 +1059,25 @@ export class Orchestrator {
     if (skills?.length && owner) input = await this.skillsPrefix(owner, skills, owner.jobs?.[job_id]?.workdir ?? null, input) ?? input;
     const lid=leaseId(profile,keyString),preamble=this.runtimeAgentPreambles?.get(lid);
     if(preamble)input=`${preamble}\n\n${input}`;
+    if (admission?.outcome?.error) return;
+    if (admission) admission.sending = true;
     try {
       await runtime.sendInput(input);
       this.runtimeAgentPreambles?.delete(lid);
+      admission?.finish(null);
     } catch (error) {
+      if (admission) admission.sending = false;
       // A turn the harness is still running (one this loop did not start, or whose end it has not heard yet) is not a
       // dead session: the line waits for that turn's end, as a refused steer does. Ending the binding on it killed a
       // live lobby manager on the first message that reached it mid-turn.
       if (/already in progress/.test(error.message)) {
+        if (admission && this.stopping) { admission.finish(new WebhookRefusal('orchestrator stopped before the worker could take this input; retry')); return; }
         this.log('info', `send ${keyString}: a turn is in progress; the line waits for its end`);
-        this.enqueue(events.worker({ profile, keyString, runtime_id: runtime.handle.runtime_id, ev: { kind: 'steer_refused', text: input }, at: this.clock() }));
+        this.enqueue(events.worker({ profile, keyString, runtime_id: runtime.handle.runtime_id, ev: { kind: 'steer_refused', text: webhook_input_id ? text : input, webhook_input_id }, at: this.clock() }));
         return;
       }
       this.enqueue(events.worker({ profile, keyString, runtime_id: runtime.handle.runtime_id, ev: { kind: 'error', message: `send failed: ${error.message}` }, at: this.clock() }));
+      admission?.finish(error);
     }
   }
 
@@ -982,14 +1133,14 @@ export class Orchestrator {
       const old = this.retired.get(runtime_id);
       this.retired.delete(runtime_id);
       this.turnCounters?.delete(runtime_id);
-      try { await old.close(); } catch { /* already gone */ }
+      try { await old.close(); } catch (error) { if (this.stopping) this.stopErrors.push(error); }
       return;
     }
     const runtime = this.runtimes.get(lid);
     if (runtime_id && runtime && runtime.handle.runtime_id !== runtime_id) return;
     this.runtimes.delete(lid);
     if (runtime) this.turnCounters?.delete(runtime.handle.runtime_id);
-    if (runtime) { try { await runtime.close(); } catch { /* already gone */ } }
+    if (runtime) { try { await runtime.close(); } catch (error) { if (this.stopping) this.stopErrors.push(error); } }
   }
 
   /**

package/mcp/mount.mjs

@@ -23,7 +23,7 @@ import { SERVER_NAME } from './tools.mjs';
 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 { installedAgentRecords } from '../installed-apps.mjs';
 import { supercodeHome } from '@volter/teams/home';
 
 export { MCP_DOORS, doorFor } from '@volter/supercode-harness-sdk/mcp-doors';
@@ -41,11 +41,12 @@ function stableSupercode() {
  * `rh2` server, whatever it holds, is neither replaced nor relied on). */
 export const RH2_AGENT_SERVER = 'rh2-agent';
 
-/** `rh2 mcp` run as the agent's installed RH2 principal: `apps mcp` puts the record's origin, organization and token in
- * its environment, so no config file carries the token. Null when no rh2-agent record is the identity of `agentId` (its
- * Teams id): a record is found by that id alone, so an agent sharing another's name is never mounted with its record. */
+/** `rh2 mcp` run as the agent's installed RH2 principal: `apps mcp` puts its first record's origin, organization and
+ * token in its environment, and the home whose records hold its other Workplaces', so no config file carries a token.
+ * Null when no rh2-agent record is an identity of `agentId` (its 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;
+  if (!installedAgentRecords(root, agentId).length) return null;
   return { command: stableSupercode(), args: ['orchestrator', 'apps', 'mcp', 'rh2-agent', '--root', root, '--agent', agentId, '--node', program] };
 }
 

package/orchestration.mjs

@@ -1,8 +1,8 @@
 // The folder, through the harness's orchestration doors.
 //
 // ONT-7: this package reads and writes its home through `harness.v1.orchestration.*`
-// (`crates/harness/src/orchestration_doors.rs`), never with a codec of its own. The
-// ontology's one codec is the Rust one; this module is its client side:
+// (the SDK's orchestration owners), never with a codec of its own. The
+// ontology's one codec is TypeScript; this module is its client side:
 //
 //   - `load(root)` asks `orchestration.load` for the orchestration value and adds the runtime
 //     half (`OrchestratorState` = orchestration + runtime, docs/ORCHESTRATOR-IR.md §2.1).
@@ -14,8 +14,7 @@
 //     moves credentials, so `import` and `export` are composed inside the
 //     harness process (see the orchestration_doors module doc).
 //
-// One door per process: the first verb spawns `supercode harness serve`
-// (the binary that spawned us, else this checkout's build) and every verb
+// One door per process: the first verb opens the SDK's owned transport and every verb
 // after it reuses it. The door is held open while a loop runs
 // (`retainWorld` / `releaseWorld`, the loop's `start` / `stop`) or a verb is
 // in flight; otherwise it closes itself after a short idle, so a process
@@ -23,26 +22,21 @@
 // `closeWorld()` closes it now.
 
 import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 import { emptyRuntime, persistedView } from './ir.mjs';
-import { lockedNative } from './source-lock.mjs';
+import { lockedProgram } from './source-lock.mjs';
+import { sourceRoot } from '@volter/supercode-teams/source-lock';
 import { SESSION_READ_REQUEST_UNITS, stringifySessionWire } from '@volter/supercode-teams/session-read-client';
 
-const here = dirname(fileURLToPath(import.meta.url));
-
-/**
- * The binary the doors are opened with: `SUPERCODE_BIN` (set by `supercode
- * orchestrator start` to the very binary that spawned the daemon), else this
- * checkout's debug build, else `supercode` on PATH.
- */
+/** Selected CLI for clients that need it: the locked Node entry, explicit
+ * override, this source tree's front door, or the installed PATH command. */
 export function supercodeCommand() {
-  const pinned = lockedNative();
+  const pinned = lockedProgram();
   if (pinned) return pinned;
   if (process.env.SUPERCODE_BIN) return process.env.SUPERCODE_BIN;
-  const built = resolve(here, '../../target/debug/supercode');
-  return existsSync(built) ? built : 'supercode';
+  const root = sourceRoot(import.meta.url);
+  return root ? join(root, 'packaging/npm/bin/supercode.js') : 'supercode';
 }
 
 const IDLE_MS = 250;

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.215",
-  "gitHead": "8267b3766f01d81c1c3e2acd3451b36aa587bf47",
+  "version": "0.5.217",
   "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": {
+    "./daemon-control": {
+      "types": "./daemon-control.d.ts",
+      "import": "./daemon-control.mjs"
+    },
     "./session-recovery": {
       "types": "./session-recovery.d.ts",
       "import": "./session-recovery.mjs"
@@ -33,10 +36,10 @@
     "check-types": "node scripts/generate-types.mjs --check"
   },
   "dependencies": {
-    "@volter/supercode-teams": "^0.3.350",
-    "@volter/supercode-terminal": "^0.3.10",
-    "@volter/supercode-harness-sdk": "^0.3.104",
-    "@volter/teams": "0.2.99",
+    "@volter/supercode-teams": "^0.3.361",
+    "@volter/supercode-terminal": "^0.3.12",
+    "@volter/supercode-harness-sdk": "^0.3.106",
+    "@volter/teams": "0.2.102",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },

package/reducer.mjs

@@ -499,7 +499,7 @@ function handleWorker(state, ev, effects) {
       const q = rt.queues[lid] ?? [];
       if (q.length && !rt.turns[lid]) {
         const next = q.shift();
-        rt.turns[lid] = { started_at: now, buffer: '' };
+        rt.turns[lid] = { started_at: now, buffer: '', ...(next.webhook_input_id ? { webhook_input_id: next.webhook_input_id } : {}) };
         effects.push(queuedInput(profile.name, ev.keyString, next));
       }
       effects.push({ type: 'save' });
@@ -507,7 +507,7 @@ function handleWorker(state, ev, effects) {
     }
     case 'steer_refused': {
       // The harness would not take the line mid-turn: it waits for the turn's end like any other.
-      (rt.queues[lid] ??= []).push({ text: w.text, at: now });
+      (rt.queues[lid] ??= []).push({ text: w.text, at: now, ...(w.webhook_input_id ? { webhook_input_id: w.webhook_input_id } : {}) });
       break;
     }
     case 'text': {
@@ -556,7 +556,7 @@ function handleWorker(state, ev, effects) {
       const q = rt.queues[lid] ?? [];
       if (q.length && rt.leases[lid]) {
         const next = q.shift();
-        rt.turns[lid] = { started_at: now, buffer: '' };
+        rt.turns[lid] = { started_at: now, buffer: '', ...(next.webhook_input_id ? { webhook_input_id: next.webhook_input_id } : {}) };
         effects.push(queuedInput(profile.name, ev.keyString, next));
       }
       // G3: the session's usage is read again from the harness's own records after every turn
@@ -630,7 +630,28 @@ export function permissionResponse(options, allow, reason = null) {
  */
 function queuedInput(profile, keyString, next) {
   const framed = next.job_id && (next.context_from || next.skills?.length);
-  return { type: 'send_input', profile, keyString, text: next.text, ...(framed ? { context_from: next.context_from ?? null, skills: next.skills ?? [], job_id: next.job_id } : {}), ...(next.history ? { history: next.history } : {}) };
+  return { type: 'send_input', profile, keyString, text: next.text, ...(framed ? { context_from: next.context_from ?? null, skills: next.skills ?? [], job_id: next.job_id } : {}), ...(next.history ? { history: next.history } : {}), ...(next.webhook_input_id ? { webhook_input_id: next.webhook_input_id } : {}) };
+}
+
+/** Remove only this unacknowledged input; a refused queue slot is no live turn. */
+function refuseWebhook(state, ev, effects) {
+  if (ev.handed) return;
+  // Only an apply that claimed this input may retire its dedup entry. A
+  // request refused before apply must not erase an earlier successful delivery.
+  if (!ev.profile || !ev.keyString) return;
+  const rt = ensureRuntime(state);
+  const seen = rt.webhook_deliveries?.[ev.name];
+  const index = seen?.indexOf(ev.delivery_id) ?? -1;
+  if (index !== -1) seen.splice(index, 1);
+  const lid = leaseId(ev.profile, ev.keyString);
+  if (rt.queues[lid]) rt.queues[lid] = rt.queues[lid].filter(row => row.webhook_input_id !== ev.admission_id);
+  if (rt.turns[lid]?.webhook_input_id !== ev.admission_id) return;
+  delete rt.turns[lid];
+  if (!ev.stopping && rt.leases[lid] && rt.queues[lid]?.length) {
+    const next = rt.queues[lid].shift();
+    rt.turns[lid] = { started_at: ev.at, buffer: '', ...(next.webhook_input_id ? { webhook_input_id: next.webhook_input_id } : {}) };
+    effects.push(queuedInput(ev.profile, ev.keyString, next));
+  }
 }
 
 /** An admin's numeric reply resolves the oldest pending request on that surface. */
@@ -688,10 +709,13 @@ function handleStopping(state, ev, effects) {
       delete b.residue.runtime_id;
       // a stop for a restart: what was live now is live again once the daemon is back (handleRestart)
       if (b.key.platform !== 'webhook' && b.key.platform !== 'cron') b.residue.reopen_at_start = true;
-      if (rt.turns[leaseId(profile.name, ks)] && !b.recurrence && b.key.platform !== 'webhook' && b.key.platform !== 'cron') {
+      if (rt.turns[leaseId(profile.name, ks)] && !b.recurrence) {
         b.residue.interrupted_at = ev.at;
-        reply(state, profile, b.key, REPLY.interrupted, ev.at, effects);
+        if (b.key.platform !== 'webhook' && b.key.platform !== 'cron') reply(state, profile, b.key, REPLY.interrupted, ev.at, effects);
       }
+      // the runtime the stop is about to close no longer serves the surface: its `closed` is not heard (handleWorker),
+      // so it cannot end a binding, or fail a fire, that the next daemon resumes
+      delete rt.leases[leaseId(profile.name, ks)];
     }
   }
   effects.push({ type: 'save' });
@@ -962,6 +986,7 @@ export function step(state, event) {
     case 'hosted_result': finishHostedFire(state, event, effects); break;
     case 'gate_result': gateResult(state, event, effects); break;
     case 'webhook': handleWebhook(state, event, effects); break;
+    case 'webhook_refused': refuseWebhook(state, event, effects); break;
     case 'restart': handleRestart(state, event, effects); break;
     case 'stopping': handleStopping(state, event, effects); break;
     case 'adapter': handleAdapter(state, event); break;