@cotal-ai/manager 0.116.0 → 0.116.2

package/dist/manager.js

@@ -17,6 +17,7 @@ import { authorizeLaunch, authorizeNamedControl } from "./authorize.js";
 import { controlShutdown } from "./control-shutdown.js";
 import { RunHosting } from "./run-hosting.js";
 import { enrolledAcl } from "./remote-authority.js";
+import { rejectionText } from "./rejection-text.js";
 import { controlSession } from "./control-session.js";
 import { MAX_AGENTS, parseResumeCommitArgs, parseResumeControlArgs, parseResumeFinalizeArgs, readSeatRecord, removeSeatRecord, writeSeatRecord } from "./resume.js";
 import { TranscriptReceiver } from "./transcript-receive.js";
@@ -159,19 +160,6 @@ function resumeOwner(entry) {
  *  dash) — what {@link Manager.psOwnerFilter} returns for an unparseable caller so a malformed
  *  principal fail-closes to an empty `ps` instead of an unbounded one. */
 const NO_OWNER_MATCHES = "-no-owner-";
-/** A caught value's text for a refusal or a log line. A host-supplied store, runtime or callback may
- *  reject with any value, including `null` or one whose `message` is a Symbol or whose `message`
- *  getter or `toString` throws. A handler that throws while building its text skips the work after
- *  it, and on a detached chain ends the manager with an unhandled rejection, so the coercion to text
- *  runs inside the guard. */
-export function rejectionText(e) {
-    try {
-        return String(e?.message ?? e);
-    }
-    catch {
-        return "an unreadable rejection";
-    }
-}
 /** A caught value as a lifecycle envelope, or undefined when it is not one. A thrown Proxy can throw
  *  from `instanceof` itself, so the test runs inside the guard. */
 function caughtEnvelope(e) {
@@ -2629,13 +2617,23 @@ export class Manager {
         }
     }
     /** Stop the v0.4 service-endpoint serve loop (drain subscriptions, await in-flight handlers)
-     *  and drop its dedicated connection. Best-effort so a graceful stop completes its remaining
-     *  teardown even when the broker is gone. */
+     *  and drop its dedicated connection, or only close the connection while its transport is down.
+     *  Best-effort so a graceful stop completes its remaining teardown even when the broker is gone. */
     async stopServiceServe() {
         const s = this.serviceServe;
         if (!s)
             return;
         this.serviceServe = undefined;
+        // A drain on a reconnecting connection does not fail: it waits for the reconnect, so the stop
+        // would last as long as the outage. A broker this connection cannot reach has nothing left to
+        // flush, so the retired connection is closed instead.
+        if (this.serveTransportDown.has(s.nc)) {
+            try {
+                await s.nc.close();
+            }
+            catch { /* best effort */ }
+            return;
+        }
         try {
             await s.handle.stop();
         }
@@ -5435,13 +5433,22 @@ export class Manager {
         // One read of the cotal config per spawn: the delegated refusal, the model policy and the launch
         // fields below all take this value, so the awaits between the policy check and the launch cannot
         // admit the seat under one file and launch it with another's servers and env allowlist. Read per
-        // spawn, so a policy edit reaches the next spawn without a restart.
+        // spawn, so a policy edit reaches the next spawn without a restart. The launch fields are resolved
+        // here too, before the spawn is accepted, so a sharing selection that names an undeclared server
+        // is refused while there is nothing to roll back.
         let cotalConfig;
+        let hostFields;
         try {
             cotalConfig = loadCotalConfig(this.workspaceRoot);
+            hostFields = this.hostLaunchFields(cotalConfig, agent, opts.shareTools, harness);
         }
         catch (e) {
-            return { ok: false, error: rejectionText(e) };
+            const error = rejectionText(e);
+            // An input refusal here precedes allocation and onAccepted, like a connector refusal above:
+            // a hosted run proves it not-executed instead of binding a goal to a spawn that never starts.
+            if (hooks?.onAccepted)
+                throw new EpEnvelopeError("failed-precondition", error, undefined, "not-executed");
+            return { ok: false, error };
         }
         // A delegated seat starts outside this host from values alone, so a choice only this host can
         // honour is refused here, before enrollment, and named rather than dropped.
@@ -5461,7 +5468,7 @@ export class Manager {
                 return { ok: false, error: `${delegatedBy}, so it cannot reopen a session held on this host (continuity: exact)` };
             if (typeof opts.cwd === "string" && opts.cwd !== "")
                 return { ok: false, error: `${delegatedBy}, so it cannot run in a directory on this host's filesystem (cwd); the seat runs in its runtime resource's own directory` };
-            const shared = Object.keys(connectorServers(cotalConfig, agent, opts.shareTools));
+            const shared = Object.keys(hostFields.mcpServers);
             if (shared.length)
                 return { ok: false, error: `${delegatedBy}, so it cannot share MCP servers that run on this host (${shared.join(", ")}); pass --share-tools none` };
         }
@@ -5897,7 +5904,7 @@ export class Manager {
                 : undefined;
             const manifestSha256 = manifestPath ? this.fileDigest(manifestPath) : undefined;
             const launchOpts = {
-                ...this.hostLaunchFields(cotalConfig, agent, opts.shareTools, harness),
+                ...hostFields,
                 name,
                 role,
                 // User mode: the principal IS the identity (the endpoint derives card.id from owner+actor);