cotal-ai 0.96.0 → 0.96.1

package/dist/daemon/client.js

@@ -44,6 +44,24 @@ export async function registerViaDaemon(opts) {
         sock.destroy();
     }
 }
+/** Ask the daemon to connect, disconnect or report its own service connection to `space`. */
+export async function serviceViaDaemon(opts) {
+    const sock = await openVerified({ ...opts, timeoutMs: 5000 });
+    try {
+        sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id: randomUUID().replaceAll("-", ""), op: opts.op, space: opts.space }));
+        // A connect runs the register replay, the first renewal, the broker connection and `ready`, each
+        // bounded by its stock client (30 s); allow for all of them.
+        const reply = JSON.parse(await readLine(sock, 130_000));
+        if (!reply.ok)
+            return { ok: false, code: reply.error.code, message: reply.error.message };
+        if ("event" in reply || !("state" in reply.result) || !("space" in reply.result))
+            return { ok: false, code: "BAD_REPLY", message: "the daemon answered the service request with something else" };
+        return { ok: true, result: reply.result };
+    }
+    finally {
+        sock.destroy();
+    }
+}
 function connectTo(path, timeoutMs) {
     return new Promise((resolve, reject) => {
         const s = netConnect(path);

package/dist/daemon/command.js

@@ -11,7 +11,9 @@
  * directory where `cotal login` keeps it, and no token ever crosses the local endpoint. The
  * connection check (`connect.ts`) reads the space's public account identity and keeps the daemon's
  * own per-space identity, never a Manager's. The registration request (`register.ts`) sends one stock
- * `register` for that identity and reports the space's answer; approval stays with the space owner. It is a
+ * `register` for that identity and reports the space's answer; approval stays with the space owner. The
+ * service connection (`service.ts`) connects that approved identity as a stock service through the stock
+ * renewal source and reports it connected only once the broker and the space's ready both accept it. It is a
  * foreground foundation, not a resilient machine service: a daemon killed without cleanup leaves
  * its socket behind, and the next start refuses until the operator removes it (see the
  * ALREADY_RUNNING remedy). `state: "ready"` means the local control listener is bound and
@@ -26,7 +28,7 @@ import { peerCredentials } from "@cotal-ai/seat";
 import { normalizeIdpUrl } from "@cotal-ai/auth";
 import { EndpointRefusal, daemonPaths } from "./endpoint.js";
 import { serveDaemon } from "./server.js";
-import { connectCheckViaDaemon, loginViaDaemon, queryDaemon, registerViaDaemon } from "./client.js";
+import { connectCheckViaDaemon, loginViaDaemon, queryDaemon, registerViaDaemon, serviceViaDaemon } from "./client.js";
 export const daemonFlags = [
     jsonFlag,
     plainFlag,
@@ -230,6 +232,43 @@ async function registerCommand(args) {
                 ] },
         ] }));
 }
+/** Connect, disconnect or read the daemon's own service connection to a space. Only `connected` (and
+ *  `disconnected` for a disconnect) exits 0; every other state is a refusal naming why. */
+async function serviceCommand(args, op) {
+    const presentation = presentationOf(args.values);
+    const space = args.values.space;
+    if (typeof space !== "string" || !space)
+        throw new CommandFailure("refused", "USAGE_INVALID", `cotal daemon ${op} needs --space <s>`);
+    let reply;
+    try {
+        reply = await serviceViaDaemon({ paths: daemonPaths(), peerUid, space, op });
+    }
+    catch (e) {
+        throw asFailure(e);
+    }
+    if (!reply.ok)
+        throw new CommandFailure("refused", "USAGE_INVALID", `the daemon refused the service request: ${reply.code} ${reply.message}`, { native: { code: reply.code } });
+    const r = reply.result;
+    const native = { native: { code: (r.state === "ended" && r.reason ? r.reason : r.state).toUpperCase().replaceAll("-", "_") } };
+    const ok = r.state === "connected" || (op === "service-disconnect" && r.state === "disconnected");
+    if (!ok) {
+        const code = r.state === "not-requested" || r.state === "not-registered" ? "TARGET_NOT_FOUND"
+            : r.state === "unsupported" ? "UNSUPPORTED"
+                : r.state === "not-signed-in" ? "AUTH_REQUIRED"
+                    : r.state === "refused" || r.state === "ended" ? "PERMISSION_DENIED"
+                        : r.state === "conflict" ? "CONFLICT"
+                            : r.state === "approval-pending" || r.state === "connecting" ? "LIFECYCLE_BLOCKED"
+                                : r.state === "disconnected" ? "TARGET_UNAVAILABLE"
+                                    : "DEPENDENCY_UNAVAILABLE";
+        throw new CommandFailure("refused", code, r.message, native);
+    }
+    writeResult(presentation, { command: `daemon ${op}`, target: { space }, result: r }, () => ({ sections: [
+            { title: r.state === "connected" ? "Connected" : "Disconnected", blocks: [
+                    { kind: "fields", rows: [["Space", r.space], ...(r.instanceId ? [["Instance", r.instanceId]] : [])] },
+                    { kind: "lines", lines: [{ text: r.message, tone: "hint" }] },
+                ] },
+        ] }));
+}
 async function serve() {
     let running;
     try {
@@ -259,14 +298,16 @@ async function run(args) {
         return connectCheckCommand(args);
     if (mode === "register")
         return registerCommand(args);
-    throw new CommandFailure("refused", "USAGE_INVALID", mode === undefined ? "cotal daemon needs a mode: status, serve, login, connect-check or register" : `unknown daemon mode ${JSON.stringify(mode)}`, { remedy: "cotal daemon status" });
+    if (mode === "service-connect" || mode === "service-disconnect" || mode === "service-status")
+        return serviceCommand(args, mode);
+    throw new CommandFailure("refused", "USAGE_INVALID", mode === undefined ? "cotal daemon needs a mode: status, serve, login, connect-check, register, service-connect, service-disconnect or service-status" : `unknown daemon mode ${JSON.stringify(mode)}`, { remedy: "cotal daemon status" });
 }
 const daemonCommand = {
     kind: "command",
     name: "daemon",
     group: "Manager",
-    summary: "the local machine daemon (Linux): serve its control endpoint, read its status, sign it in, check and request its own registration with a space",
-    positionals: "<status|serve|login|connect-check|register>",
+    summary: "the local machine daemon (Linux): serve its control endpoint, read its status, sign it in, check and request its own registration with a space, and connect it as its own service",
+    positionals: "<status|serve|login|connect-check|register|service-connect|service-disconnect|service-status>",
     flags: daemonFlags,
     subcommands: [
         { name: "status", summary: "ask the running daemon for its status over the local endpoint", flagNames: ["json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
@@ -274,9 +315,12 @@ const daemonCommand = {
         { name: "login", summary: "sign the running daemon in to a provider with device approval; the daemon keeps the session", flagNames: ["idp", "client-id", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
         { name: "connect-check", summary: "ask the running daemon whether it could register with a space as its own service; registers nothing", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
         { name: "register", summary: "ask the running daemon to request its own service registration with a space; the space owner must approve it, and it does not connect", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "service-connect", summary: "connect the running daemon to a space as its own approved service; succeeds only when the broker accepts the connection and the space accepts it as ready", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "service-disconnect", summary: "close the running daemon's service connection to a space", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
+        { name: "service-status", summary: "read the running daemon's service connection to a space, without contacting it", flagNames: ["space", "json", "plain"], outputs: ["json", "plain"], reads: true, prepareMeshTarget: false },
     ],
     prepareMeshTarget: false,
-    examples: ["cotal daemon serve", "cotal daemon status", "cotal daemon status --json", "cotal daemon login --idp https://example.org/api/auth", "cotal daemon connect-check --space acme", "cotal daemon register --space acme"],
+    examples: ["cotal daemon serve", "cotal daemon status", "cotal daemon status --json", "cotal daemon login --idp https://example.org/api/auth", "cotal daemon connect-check --space acme", "cotal daemon register --space acme", "cotal daemon service-connect --space acme", "cotal daemon service-status --space acme"],
     run,
 };
 registry.register(daemonCommand);

package/dist/daemon/protocol.js

@@ -13,7 +13,7 @@
  */
 import { normalizeIdpUrl } from "@cotal-ai/auth";
 import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES } from "./endpoint.js";
-export const DAEMON_OPS = ["status", "login-start", "login-cancel", "connect-check", "register"];
+export const DAEMON_OPS = ["status", "login-start", "login-cancel", "connect-check", "register", "service-connect", "service-disconnect", "service-status"];
 /** The fields each op takes besides `v`, `id` and `op`. Required ones must be present. */
 const OP_FIELDS = {
     status: { required: [], optional: [] },
@@ -21,6 +21,9 @@ const OP_FIELDS = {
     "login-cancel": { required: ["attempt"], optional: [] },
     "connect-check": { required: ["space"], optional: [] },
     register: { required: ["space"], optional: [] },
+    "service-connect": { required: ["space"], optional: [] },
+    "service-disconnect": { required: ["space"], optional: [] },
+    "service-status": { required: ["space"], optional: [] },
 };
 const ENVELOPE_KEYS = new Set(["v", "id", "op"]);
 const ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
@@ -65,7 +68,7 @@ export function parseRequest(line) {
             return bad(id, "attempt must be the 22-character attempt id from login-prompt");
         return { ok: true, request: { v, id, op, attempt: obj.attempt } };
     }
-    if (op === "connect-check" || op === "register") {
+    if (op === "connect-check" || op === "register" || op === "service-connect" || op === "service-disconnect" || op === "service-status") {
         if (typeof obj.space !== "string" || !SPACE_PATTERN.test(obj.space))
             return bad(id, "space must be 1-64 characters of [A-Za-z0-9_-]");
         return { ok: true, request: { v, id, op, space: obj.space } };

package/dist/daemon/register.js

@@ -70,6 +70,21 @@ const NOT_SIGNED_IN = "this machine's sign-in was not accepted by the space's pr
 const NOT_SENT = "the daemon could not send the registration request; nothing was sent and nothing is connected";
 const UNUSABLE = "the space answered the registration with something the daemon does not use; run the same command again";
 export async function registerDaemon(space, home = homeCotalDir()) {
+    const sent = await sendRegister(space, home);
+    return "outcome" in sent ? sent : registerAnswer(sent.result, sent.ids);
+}
+/** The stock witness this daemon's own registration holds in `space`, read by replaying its persisted
+ *  register request unchanged: the same requestId and body, so no new key or registration. Anything
+ *  but `registered` is returned as the daemon's register outcome. */
+export async function daemonWitness(space, home = homeCotalDir()) {
+    const sent = await sendRegister(space, home);
+    if ("outcome" in sent)
+        return sent;
+    if (sent.result.state === "registered")
+        return { witness: sent.result.witness };
+    return registerAnswer(sent.result, sent.ids);
+}
+async function sendRegister(space, home) {
     const ready = await connectCheck(space, home);
     if (ready.outcome !== "ready-to-register")
         return ready;
@@ -109,7 +124,7 @@ export async function registerDaemon(space, home = homeCotalDir()) {
             return { outcome: "not-signed-in", space, message: NOT_SIGNED_IN };
         return { outcome: "refused", space, message: NOT_SENT };
     }
-    return registerAnswer(result, ids);
+    return { result, ids };
 }
 /** The daemon's outcome for one stock register answer. */
 export function registerAnswer(result, ids) {

package/dist/daemon/server.js

@@ -17,6 +17,7 @@ import { encode, parseRequest } from "./protocol.js";
 import { createLoginCoordinator } from "./login.js";
 import { connectCheck } from "./connect.js";
 import { registerDaemon } from "./register.js";
+import { createServiceConnections } from "./service.js";
 import { homeCotalDir } from "@cotal-ai/workspace";
 /** Requests one connection may send. A sign-in needs two (start, cancel); status polling a few. */
 export const MAX_REQUESTS_PER_CONNECTION = 64;
@@ -42,9 +43,10 @@ export async function serveDaemon(opts) {
     const { paths } = opts;
     const dirOutcome = ensureDir(paths.dir, uid);
     refuseExisting(paths.socket);
-    const counters = { accepted: 0, peerRejected: 0, framesDecoded: 0, requestsRefused: 0, statusAnswered: 0, loginsStarted: 0, loginsRefused: 0, cancelsAnswered: 0, connectChecksAnswered: 0, registersAnswered: 0 };
+    const counters = { accepted: 0, peerRejected: 0, framesDecoded: 0, requestsRefused: 0, statusAnswered: 0, loginsStarted: 0, loginsRefused: 0, cancelsAnswered: 0, connectChecksAnswered: 0, registersAnswered: 0, serviceAnswered: 0 };
     const machineHome = opts.sessionDir ?? homeCotalDir();
     const login = opts.login ?? createLoginCoordinator({ sessionDir: machineHome });
+    const services = createServiceConnections(machineHome);
     const startedAt = new Date();
     const status = () => ({
         state: "ready",
@@ -128,6 +130,16 @@ export async function serveDaemon(opts) {
                 });
                 return;
             }
+            if (req.op === "service-connect" || req.op === "service-disconnect" || req.op === "service-status") {
+                const run = req.op === "service-status" ? Promise.resolve(services.status(req.space))
+                    : (req.op === "service-connect" ? services.connect(req.space) : services.disconnect(req.space))
+                        .catch(() => ({ space: req.space, state: "unavailable", message: "the daemon could not complete the request; nothing is connected" }));
+                void run.then((result) => {
+                    counters.serviceAnswered++;
+                    return write({ v: DAEMON_PROTOCOL_VERSION, id: req.id, ok: true, result });
+                });
+                return;
+            }
             if (req.op === "login-cancel") {
                 void login.cancel(req.attempt).then((result) => {
                     counters.cancelsAnswered++;
@@ -231,6 +243,8 @@ export async function serveDaemon(opts) {
         closed ??= (async () => {
             // An in-flight sign-in is cancelled through the stock fence before the listener goes away.
             await login.close();
+            // Every service connection, its endpoint and its renewal source close before the socket does.
+            await services.close();
             for (const s of sockets)
                 s.destroy();
             await new Promise((r) => server.close(() => r()));

package/dist/daemon/service.js

@@ -0,0 +1,339 @@
+/**
+ * The daemon's own service connection to a space (A2c): its registered `ai.cotal.machine` instance,
+ * connected as a stock service and accepted by the space as ready.
+ *
+ * - The witness comes from replaying the daemon's persisted register request unchanged
+ *   (`daemonWitness`): no new key, no new registration, no changed body. Without a register request
+ *   nothing is sent.
+ * - The credentials come from the stock renewal source (`AuthProvider.serviceEndpointRenewal`) over
+ *   the daemon's private store in the machine home. Only the renewal and ready records live there;
+ *   the source's other reads (the space's sentinel) come from the space's own workspace store, which
+ *   the daemon never writes.
+ * - The connection is a real `CotalEndpoint` with the source as its bearer function, admitted by the
+ *   space's native service callout. Its reconnect and refresh schedule is the endpoint's own.
+ * - `connected` means both: the endpoint reports its broker connection up, and the space answered
+ *   stock `ready` for this witness. The broker connection is read from the endpoint's `transport`
+ *   edge (a transient loss while nats.js reconnects) and its `connection` edge (a rebuild, teardown
+ *   or close). Either going down withdraws `connected` at once, as `connecting`; it is claimed again
+ *   only after the broker is back and the space answers a fresh `ready`.
+ *
+ * No liveness command is served: the registered `machine-status` command has void output and a
+ * service connection gets no stock serve grant (see the connect contract). No token, proof or
+ * provider text leaves this module; every message is fixed text.
+ */
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { CotalEndpoint, resolveAuthProvider, ServiceAuthorityTransportError, serviceWitnessDigest, } from "@cotal-ai/core";
+import { FsSecretStore, findMesh, homeCotalDir, spaceSegment, userAuthStateDir, workspaceSecretStore } from "@cotal-ai/workspace";
+import { daemonRegisterFile, daemonWitness } from "./register.js";
+const SENTENCE = {
+    "not-requested": "this daemon has not requested registration with this space; run `cotal daemon register --space <s>` first",
+    "not-registered": "this space is not registered on this machine; add it with `cotal meshes add`",
+    "not-signed-in": "this machine is not signed in to the space's provider; run `cotal daemon login --idp <url>`",
+    unsupported: "the space's auth service does not host service endpoints, so the daemon cannot connect to it",
+    "approval-pending": "the space owner has not approved this daemon yet, or the space is still registering it; nothing is connected",
+    refused: "the space refused this daemon's registration; nothing is connected",
+    conflict: "this daemon's registration does not match what the space holds; nothing is connected",
+    connecting: "the daemon is connecting to the space; it is not connected yet",
+    connected: "connected: the broker accepted this daemon's service connection and the space accepted it as ready",
+    unavailable: "the space or its broker could not be reached; nothing is connected, and connecting again retries the same requests",
+    ended: "the space ended this daemon's service authority; nothing is connected, and connecting again will not reconnect it",
+    disconnected: "not connected",
+};
+/** Codes reported by name when the space ends the connection. Any other is `unrecognized`. */
+const ENDED = new Set(["expired", "approval-revoked", "root-revoked", "stale-witness", "permission-denied", "unauthenticated", "proof-mismatch",
+    "unsupported", "conflict", "resource-exhausted", "registration-pending", "bad-request", "registration-active", "approval-mismatch", "not-found"]);
+/** The renewal source's own record keys go to the daemon's private store; every other key the source
+ *  reads (the space's client sentinel) comes from the space's workspace store, read only. */
+function daemonServiceStore(home, space, workspace) {
+    const own = new FsSecretStore(join(home, "daemon", spaceSegment(space), "service-store"));
+    const ownKey = (k) => k.startsWith(`auth/${spaceSegment(space)}/service-renewal/`) || k.startsWith("daemon-ready/");
+    return {
+        get identity() { return own.identity; },
+        get: (k) => (ownKey(k) ? own.get(k) : workspace.get(k)),
+        put: (k, v) => { if (!ownKey(k))
+            throw new Error("the daemon writes only its own service records"); return own.put(k, v); },
+        create: (k, v) => { if (!ownKey(k))
+            throw new Error("the daemon writes only its own service records"); return own.create(k, v); },
+        delete: (k) => { if (!ownKey(k))
+            throw new Error("the daemon writes only its own service records"); return own.delete(k); },
+    };
+}
+const HEX32 = /^[0-9a-f]{32}$/;
+const readyKey = (witness) => `daemon-ready/${serviceWitnessDigest(witness).slice("sha256:".length)}.json`;
+const readyId = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    try {
+        const o = JSON.parse(raw);
+        return o.v === 1 && typeof o.requestId === "string" && HEX32.test(o.requestId) ? o.requestId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** The one persisted ready request id for `witness`, minted and created before its first use.
+ *  `undefined` when the store fails or holds a record that is not one (never its text). */
+async function readyRequestId(store, witness) {
+    const key = readyKey(witness);
+    try {
+        const stored = await store.get(key);
+        if (stored !== undefined)
+            return readyId(stored);
+        const minted = randomBytes(16).toString("hex");
+        if (await store.create(key, JSON.stringify({ v: 1, requestId: minted })))
+            return minted;
+        return readyId(await store.get(key));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createServiceConnections(home = homeCotalDir()) {
+    const live = new Map();
+    const queue = new Map();
+    let closed = false;
+    const result = (space) => {
+        const l = live.get(space);
+        const state = l?.state ?? "disconnected";
+        return { space, state, message: SENTENCE[state], ...(l?.instanceId ? { instanceId: l.instanceId } : {}),
+            ...(state === "ended" && l?.reason ? { reason: l.reason } : {}) };
+    };
+    /** One operation per space at a time: concurrent connects share the outcome of the first. */
+    const serial = (space, op) => {
+        const next = (queue.get(space) ?? Promise.resolve()).then(op, op);
+        queue.set(space, next.catch(() => { }));
+        return next;
+    };
+    /** State changes from endpoint callbacks between awaits; read it fresh. */
+    const stateOf = (l) => l.state;
+    async function teardown(l) {
+        l.closing ??= (async () => {
+            const ep = l.endpoint, src = l.source;
+            l.endpoint = undefined;
+            l.source = undefined;
+            l.brokerUp = false;
+            await ep?.stop().catch(() => { });
+            await src?.close().catch(() => { });
+        })();
+        await l.closing;
+        l.closing = undefined;
+    }
+    const fromRegister = (r) => {
+        switch (r.outcome) {
+            case "approval-required":
+            case "pending": return "approval-pending";
+            case "refused": return "reason" in r ? "refused" : "unavailable";
+            case "not-signed-in": return "not-signed-in";
+            case "not-registered": return "not-registered";
+            case "not-user-auth":
+            case "unsupported-by-space": return "unsupported";
+            case "account-mismatch":
+            case "conflict": return "conflict";
+            default: return "unavailable";
+        }
+    };
+    /** Ask the space to accept this witness as ready, on a fresh access bearer from the source, under
+     *  one persisted ready request per witness. Sets `connected` only if the broker is still up. */
+    async function ready(l, space, witness, store, dir) {
+        const provider = resolveAuthProvider();
+        const requestId = await readyRequestId(store, witness);
+        if (requestId === undefined) {
+            l.state = "unavailable";
+            return;
+        }
+        let token;
+        try {
+            token = await l.source.bearer();
+        }
+        catch {
+            return sourceFailed(l);
+        }
+        let answer;
+        try {
+            answer = (await provider.serviceEndpointAuthority({ store, dir, request: { v: 1, kind: "service-endpoint-authority", operation: "ready", requestId,
+                    space, accountPublicKey: witness.accountPublicKey, endpoint: witness.endpoint, instanceId: witness.instanceId, witness },
+                proof: { kind: "service-access", token } })).result;
+        }
+        catch (e) {
+            if (!(e instanceof ServiceAuthorityTransportError)) { /* a local failure: no claim */ }
+            l.state = "unavailable";
+            return;
+        }
+        if (answer.state === "ready") {
+            l.state = l.brokerUp && l.endpoint ? "connected" : "connecting";
+            return;
+        }
+        if (answer.state === "denied" && answer.reason === "rate-limited") {
+            l.state = "unavailable";
+            return;
+        }
+        l.state = "ended";
+        l.reason = answer.state === "denied" && ENDED.has(answer.reason) ? answer.reason : "unrecognized";
+        await teardown(l);
+    }
+    /** Start a `ready` for the current broker connection, at most one at a time. Never rejects: a
+     *  failure leaves the state not connected. */
+    function readyOnce(l, space, witness, store, dir) {
+        l.readying ??= ready(l, space, witness, store, dir)
+            .catch(() => { if (l.state !== "ended")
+            l.state = "unavailable"; })
+            .finally(() => { l.readying = undefined; });
+        return l.readying;
+    }
+    function sourceFailed(l) {
+        const s = l.source?.state();
+        if (s?.state === "ended") {
+            l.state = "ended";
+            l.reason = ENDED.has(s.reason) ? s.reason : "unrecognized";
+        }
+        else
+            l.state = "unavailable";
+    }
+    /** Any throw inside a connect leaves nothing running: the endpoint and source are torn down and
+     *  the answer is a fixed `unavailable`. */
+    async function connectOnce(space) {
+        try {
+            return await connectInner(space);
+        }
+        catch {
+            const l = live.get(space);
+            if (l) {
+                await teardown(l).catch(() => { });
+                if (l.state !== "ended")
+                    l.state = "unavailable";
+            }
+            return result(space);
+        }
+    }
+    async function connectInner(space) {
+        if (closed)
+            return { space, state: "disconnected", message: SENTENCE.disconnected };
+        const current = live.get(space);
+        if (current?.state === "ended")
+            return result(space);
+        if (current?.endpoint && current.state === "connected")
+            return result(space);
+        if (current)
+            await teardown(current);
+        const l = current ?? { state: "connecting", brokerUp: false };
+        l.state = "connecting";
+        l.reason = undefined;
+        live.set(space, l);
+        if (!existsSync(daemonRegisterFile(space, home))) {
+            l.state = "not-requested";
+            return result(space);
+        }
+        const entry = findMesh(space);
+        if (!entry || entry.mode !== "user" || !entry.userAuth) {
+            l.state = entry ? "unsupported" : "not-registered";
+            return result(space);
+        }
+        const w = await daemonWitness(space, home);
+        if ("outcome" in w) {
+            l.state = fromRegister(w);
+            return result(space);
+        }
+        const witness = w.witness;
+        l.instanceId = witness.instanceId;
+        const provider = resolveAuthProvider();
+        if (!provider.serviceEndpointRenewal || !provider.serviceEndpointAuthority) {
+            l.state = "unsupported";
+            return result(space);
+        }
+        const store = daemonServiceStore(home, space, workspaceSecretStore(entry.root));
+        const dir = userAuthStateDir(entry.root, space, { readOnly: true });
+        const source = provider.serviceEndpointRenewal({ store, dir, witness });
+        l.source = source;
+        try {
+            await source.bearer();
+        }
+        catch {
+            sourceFailed(l);
+            await teardown(l);
+            return result(space);
+        }
+        const onEnd = () => {
+            // The source ends inside the endpoint's own refresh: tear down after that call returns.
+            if (source.state().state === "ended" && l.source === source) {
+                sourceFailed(l);
+                setImmediate(() => void teardown(l));
+            }
+        };
+        const endpoint = new CotalEndpoint({
+            space, servers: entry.server, sentinelCreds: source.sentinelCreds,
+            bearer: async () => { try {
+                return await source.bearer();
+            }
+            finally {
+                onEnd();
+            } },
+            card: { name: "cotal-daemon", kind: "endpoint", owner: witness.principal.owner, actor: witness.principal.actor },
+            channels: [], registerPresence: false, watchPresence: false, watchChannels: false, consume: false,
+        });
+        // Conditions the endpoint survives (renewal retries, reconnects) are not reported: their text can
+        // carry provider wording. State below is derived from the connection edge and the space's answers.
+        endpoint.on("warning", () => { });
+        endpoint.on("error", () => { });
+        // The broker edge while nats.js reconnects on its own: no claim while it is down.
+        endpoint.on("transport", (e) => {
+            if (l.endpoint !== endpoint)
+                return;
+            l.brokerUp = e.connected;
+            if (!e.connected) {
+                if (l.state === "connected")
+                    l.state = "connecting";
+                return;
+            }
+            if (l.state !== "ended")
+                void readyOnce(l, space, witness, store, dir);
+        });
+        endpoint.on("connection", (e) => {
+            if (l.endpoint !== endpoint)
+                return;
+            l.brokerUp = e.connected;
+            if (!e.connected) {
+                if (l.state === "connected")
+                    l.state = "connecting";
+                return;
+            }
+            if (l.state !== "ended")
+                void readyOnce(l, space, witness, store, dir);
+        });
+        l.endpoint = endpoint;
+        try {
+            await endpoint.start();
+        }
+        catch {
+            if (stateOf(l) !== "ended")
+                l.state = "unavailable";
+            await teardown(l);
+            return result(space);
+        }
+        l.brokerUp = true;
+        await readyOnce(l, space, witness, store, dir);
+        const after = stateOf(l);
+        if (after !== "connected" && after !== "ended") {
+            await teardown(l);
+        }
+        return result(space);
+    }
+    return {
+        connect: (space) => serial(space, () => connectOnce(space)),
+        disconnect: (space) => serial(space, async () => {
+            const l = live.get(space);
+            if (l) {
+                await teardown(l);
+                live.delete(space);
+            }
+            return { space, state: "disconnected", message: SENTENCE.disconnected };
+        }),
+        status: (space) => result(space),
+        async close() {
+            closed = true;
+            await Promise.all([...live.values()].map((l) => teardown(l)));
+            live.clear();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cotal-ai",
-  "version": "0.96.0",
+  "version": "0.96.1",
   "description": "Cotal — lateral agent coordination over NATS. Run `npx cotal-ai` for the CLI.",
   "license": "Apache-2.0",
   "keywords": [
@@ -33,26 +33,26 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@cotal-ai/auth": "0.96.0",
-    "@cotal-ai/cli": "0.96.0",
-    "@cotal-ai/connector-core": "0.96.0",
-    "@cotal-ai/core": "0.96.0",
-    "@cotal-ai/delivery": "0.96.0",
-    "@cotal-ai/manager": "0.96.0",
-    "@cotal-ai/runtime": "0.96.0",
-    "@cotal-ai/seat": "0.96.0",
-    "@cotal-ai/workspace": "0.96.0"
+    "@cotal-ai/auth": "0.96.1",
+    "@cotal-ai/cli": "0.96.1",
+    "@cotal-ai/connector-core": "0.96.1",
+    "@cotal-ai/core": "0.96.1",
+    "@cotal-ai/delivery": "0.96.1",
+    "@cotal-ai/manager": "0.96.1",
+    "@cotal-ai/runtime": "0.96.1",
+    "@cotal-ai/seat": "0.96.1",
+    "@cotal-ai/workspace": "0.96.1"
   },
   "devDependencies": {
-    "@cotal-ai/connector-claude-code": "0.96.0",
-    "@cotal-ai/connector-codex": "0.96.0",
-    "@cotal-ai/connector-hermes": "0.96.0",
-    "@cotal-ai/connector-jcode": "0.96.0",
-    "@cotal-ai/connector-opencode": "0.96.0",
-    "@cotal-ai/linear": "0.96.0",
-    "@cotal-ai/pi": "0.96.0",
+    "@cotal-ai/connector-claude-code": "0.96.1",
+    "@cotal-ai/connector-codex": "0.96.1",
+    "@cotal-ai/connector-hermes": "0.96.1",
+    "@cotal-ai/connector-jcode": "0.96.1",
+    "@cotal-ai/connector-opencode": "0.96.1",
+    "@cotal-ai/linear": "0.96.1",
+    "@cotal-ai/pi": "0.96.1",
     "@cotal-ai/smoke-kit": "0.0.0",
-    "@cotal-ai/web": "0.96.0",
+    "@cotal-ai/web": "0.96.1",
     "@nats-io/jetstream": "^3.4.0",
     "@nats-io/transport-node": "^3.4.0",
     "typescript": "^5.9.3"