cotal-ai 0.95.0 → 0.95.1

package/dist/daemon/client.js

@@ -27,6 +27,23 @@ export async function connectCheckViaDaemon(opts) {
         sock.destroy();
     }
 }
+/** Ask the daemon to submit its own service registration for `space` and report the space's answer. */
+export async function registerViaDaemon(opts) {
+    const sock = await openVerified({ ...opts, timeoutMs: 5000 });
+    try {
+        sock.write(encode({ v: DAEMON_PROTOCOL_VERSION, id: randomUUID().replaceAll("-", ""), op: "register", space: opts.space }));
+        // Readiness read plus the stock register call, each bounded by the stock client (30 s).
+        const reply = JSON.parse(await readLine(sock, 65_000));
+        if (!reply.ok)
+            return { ok: false, code: reply.error.code, message: reply.error.message };
+        if ("event" in reply || !("outcome" in reply.result) || !("space" in reply.result))
+            return { ok: false, code: "BAD_REPLY", message: "the daemon answered the registration 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

@@ -3,13 +3,15 @@
  * in an `implementations/*` package so it can later wire `@cotal-ai/auth` and `@cotal-ai/manager`
  * without one implementation importing another (AGENTS.md, repository map).
  *
- * This slice serves a local, authenticated endpoint for status, sign-in and a connection check, and
- * nothing else: no registration, no Manager, no mesh or Cloud connection, no service install. Linux
+ * This slice serves a local, authenticated endpoint for status, sign-in, a connection check and a
+ * registration request, and nothing else: no activation or serving, no Manager, no mesh or Cloud
+ * connection, no service install. Linux
  * only. Sign-in runs inside the
  * daemon through stock `establishIdpSession`, so the session lands in the machine-home Cotal
  * 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. It is a
+ * 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
  * 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
@@ -24,7 +26,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 } from "./client.js";
+import { connectCheckViaDaemon, loginViaDaemon, queryDaemon, registerViaDaemon } from "./client.js";
 export const daemonFlags = [
     jsonFlag,
     plainFlag,
@@ -187,6 +189,47 @@ async function connectCheckCommand(args) {
                 ] },
         ] }));
 }
+/** Ask the running daemon to submit its own service registration for a space. The space owner's
+ *  approval and the operator's name binding happen elsewhere; this never activates or serves. */
+async function registerCommand(args) {
+    const presentation = presentationOf(args.values);
+    const space = args.values.space;
+    if (typeof space !== "string" || !space)
+        throw new CommandFailure("refused", "USAGE_INVALID", "cotal daemon register needs --space <s>");
+    let reply;
+    try {
+        reply = await registerViaDaemon({ paths: daemonPaths(), peerUid, space });
+    }
+    catch (e) {
+        throw asFailure(e);
+    }
+    if (!reply.ok)
+        throw new CommandFailure("refused", "USAGE_INVALID", `the daemon refused the registration request: ${reply.code} ${reply.message}`, { native: { code: reply.code } });
+    const r = reply.result;
+    const native = { native: { code: (r.outcome === "refused" && "reason" in r ? r.reason : r.outcome).toUpperCase().replaceAll("-", "_") } };
+    if (r.outcome === "not-registered")
+        throw new CommandFailure("refused", "TARGET_NOT_FOUND", r.message, native);
+    if (r.outcome === "not-user-auth" || r.outcome === "unsupported-by-space")
+        throw new CommandFailure("refused", "UNSUPPORTED", r.message, native);
+    if (r.outcome === "not-signed-in")
+        throw new CommandFailure("refused", "AUTH_REQUIRED", r.message, native);
+    if (r.outcome === "unreachable")
+        throw new CommandFailure("refused", "DEPENDENCY_UNAVAILABLE", r.message, native);
+    if (r.outcome === "account-mismatch" || r.outcome === "conflict")
+        throw new CommandFailure("refused", "CONFLICT", r.message, native);
+    // Only a refusal carrying the space's stock reason is a denial; one without is the daemon's own failure.
+    if (r.outcome === "refused")
+        throw new CommandFailure("refused", "reason" in r ? "PERMISSION_DENIED" : "DEPENDENCY_UNAVAILABLE", r.message, native);
+    if (r.outcome !== "approval-required" && r.outcome !== "pending" && r.outcome !== "registered")
+        throw new CommandFailure("unknown", "OPERATION_UNKNOWN", r.message, native);
+    const title = r.outcome === "approval-required" ? "Waiting for the space owner" : r.outcome === "pending" ? "Registration in progress" : "Registered, not connected";
+    writeResult(presentation, { command: "daemon register", target: { space }, result: r }, () => ({ sections: [
+            { title, blocks: [
+                    { kind: "fields", rows: [["Space", r.space], ["Service", r.endpoint], ["Instance", r.instanceId], ["Request", r.requestId]] },
+                    { kind: "lines", lines: [{ text: r.message, tone: "hint" }] },
+                ] },
+        ] }));
+}
 async function serve() {
     let running;
     try {
@@ -214,23 +257,26 @@ async function run(args) {
         return login(args);
     if (mode === "connect-check")
         return connectCheckCommand(args);
-    throw new CommandFailure("refused", "USAGE_INVALID", mode === undefined ? "cotal daemon needs a mode: status, serve, login or connect-check" : `unknown daemon mode ${JSON.stringify(mode)}`, { remedy: "cotal daemon status" });
+    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" });
 }
 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 whether it can connect to a space",
-    positionals: "<status|serve|login|connect-check>",
+    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>",
     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 },
         { name: "serve", summary: "run the daemon in the foreground and serve its local endpoint (refusals honor --json)", flagNames: ["json", "plain"], outputs: ["json", "plain"], prepareMeshTarget: false },
         { 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 },
     ],
     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"],
+    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"],
     run,
 };
 registry.register(daemonCommand);

package/dist/daemon/protocol.js

@@ -13,13 +13,14 @@
  */
 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"];
+export const DAEMON_OPS = ["status", "login-start", "login-cancel", "connect-check", "register"];
 /** The fields each op takes besides `v`, `id` and `op`. Required ones must be present. */
 const OP_FIELDS = {
     status: { required: [], optional: [] },
     "login-start": { required: ["idp"], optional: ["clientId"] },
     "login-cancel": { required: ["attempt"], optional: [] },
     "connect-check": { required: ["space"], optional: [] },
+    register: { required: ["space"], optional: [] },
 };
 const ENVELOPE_KEYS = new Set(["v", "id", "op"]);
 const ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
@@ -64,7 +65,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") {
+    if (op === "connect-check" || op === "register") {
         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

@@ -0,0 +1,138 @@
+/**
+ * The daemon's own service registration (A2b.2). It submits ONE stock `register` request for the
+ * daemon's A2b.1 identity and reports the stock answer. It never activates, serves, holds a bearer,
+ * decides, binds a name or grants a caller, and it never touches a Manager.
+ *
+ * It runs the A2b.1 readiness check first. Any outcome other than `ready-to-register` is returned
+ * unchanged, so a space without service endpoints gets 0 POST and no identity.
+ *
+ * Request identity follows the stock rule (docs/embedding.md, "Service authority contracts"): one
+ * requestId per instance and body. It is persisted with the body digest before the first send, through
+ * stock `claimIdentityRecord`, and replayed unchanged on every later call, restarts included. The host
+ * bounds an instance to 64 distinct requests, so a fresh key is never minted for the same instance. A
+ * different body for the same instance is refused locally.
+ *
+ * The request goes through the registered auth provider's `serviceEndpointAuthority` with no proof
+ * argument, so the stock client presents the machine's signed-in IdP proof itself. The daemon never
+ * reads or relays that proof.
+ */
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { contractDigest, resolveAuthProvider, ServiceAuthorityTransportError, singleDocumentClosure, VOID_SCHEMA_DIGEST } from "@cotal-ai/core";
+import { claimIdentityRecord, findMesh, homeCotalDir, spaceSegment, userAuthStateDir, workspaceSecretStore } from "@cotal-ai/workspace";
+import { connectCheck, DAEMON_ENDPOINT } from "./connect.js";
+/** The daemon's contract: one cluster with one read command, declared for the later telemetry slice.
+ *  It is ephemeral, untargeted and ungoverned, the only shape the service door admits. Nothing serves it yet. */
+const CLUSTER = { urn: DAEMON_ENDPOINT, revision: 1, attributes: [], events: [],
+    commands: [{ name: "machine-status", class: "ephemeral", targeted: false, capability: "read", inputDigest: VOID_SCHEMA_DIGEST, outputDigest: VOID_SCHEMA_DIGEST }] };
+const closure = singleDocumentClosure(CLUSTER);
+const REGISTRATION = { clusterDigests: [closure.closureDigest], contractArtifacts: [closure.manifest, CLUSTER] };
+const KIND = "cotal-daemon-register-request";
+export function daemonRegisterFile(space, home = homeCotalDir()) {
+    return join(home, "daemon", spaceSegment(space), "register-request.json");
+}
+const parseRecord = (space) => (raw) => {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const o = raw;
+    if (Object.keys(o).sort().join(",") !== "bodyDigest,instanceId,kind,requestId,space,v")
+        return undefined;
+    if (o.v !== 1 || o.kind !== KIND || o.space !== space || typeof o.instanceId !== "string" || typeof o.bodyDigest !== "string")
+        return undefined;
+    if (typeof o.requestId !== "string" || !/^[0-9a-f]{32}$/.test(o.requestId))
+        return undefined;
+    return o;
+};
+/** Fixed sentences for the stock register denial codes (`service-endpoint-authority.ts` register
+ *  door and its host). Any other code is reported as {@link UNRECOGNIZED}, so no remote text crosses
+ *  the endpoint. */
+const DENIED = {
+    "proposal-refused": "the space owner refused this daemon; a new proposal needs a new request, which this command does not send",
+    "proposal-expired": "the space owner did not decide before the proposal expired; a new proposal needs a new request, which this command does not send",
+    "approval-revoked": "the space owner revoked this daemon's approval",
+    "permission-denied": "the signed-in account may not register services in this space",
+    conflict: "the space already holds a different registration for this daemon's instance",
+    expired: "the space's approval for this daemon has expired",
+    "bad-request": "the space refused the registration request as malformed",
+    "closure-invalid": "the space refused the daemon's contract",
+    "unsupported-runtime": "the space refused the daemon's contract",
+    unsupported: "the space does not support this registration",
+    unauthenticated: "the space did not accept this machine's sign-in",
+    "rate-limited": "the space is rate-limiting registrations; try again later",
+    "resource-exhausted": "the space has no room left for this daemon's requests",
+};
+const UNRECOGNIZED = "unrecognized";
+/** The stock register pending phase (`approved-unregistered`); any other is reported as {@link UNRECOGNIZED}. */
+const PHASES = new Set(["approved-unregistered"]);
+/** A stock proposal id: 64 lowercase hex characters (`service-host-ops.ts`, `hexN(proposalId, 64)`). */
+const PROPOSAL_ID = /^[0-9a-f]{64}$/;
+const NOT_SIGNED_IN = "this machine's sign-in was not accepted by the space's provider (expired, revoked or missing); run `cotal daemon login --idp <url>`";
+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 ready = await connectCheck(space, home);
+    if (ready.outcome !== "ready-to-register")
+        return ready;
+    const entry = findMesh(space);
+    const base = {
+        v: 1, kind: "service-endpoint-authority", operation: "register", space,
+        accountPublicKey: ready.accountPublicKey, endpoint: ready.endpoint, instanceId: ready.instanceId,
+        registration: REGISTRATION, expected: { state: "unregistered" },
+    };
+    const bodyDigest = contractDigest(base);
+    const record = claimIdentityRecord(daemonRegisterFile(space, home), "daemon register request", parseRecord(space), () => ({
+        v: 1, kind: KIND, space, instanceId: ready.instanceId, requestId: randomBytes(16).toString("hex"), bodyDigest,
+    }));
+    if (record.instanceId !== ready.instanceId || record.bodyDigest !== bodyDigest)
+        return { outcome: "conflict", space, requestId: record.requestId,
+            message: "this daemon already sent a different registration for this space; nothing was sent. Confirm the change before removing its register request file by hand" };
+    const request = { ...base, requestId: record.requestId };
+    const ids = { space, requestId: record.requestId, endpoint: ready.endpoint, instanceId: ready.instanceId };
+    let result;
+    try {
+        const provider = resolveAuthProvider();
+        if (!provider.serviceEndpointAuthority)
+            return { outcome: "unsupported-by-space", space, message: "the space's auth service does not host service endpoints, so the daemon cannot register with it" };
+        result = (await provider.serviceEndpointAuthority({ store: workspaceSecretStore(entry.root), dir: userAuthStateDir(entry.root, space, { readOnly: true }), request })).result;
+    }
+    catch (e) {
+        const status = e.httpStatus;
+        if (status === 404)
+            return { outcome: "unsupported-by-space", space, message: "the space's auth service does not host service endpoints, so the daemon cannot register with it" };
+        // Only the stock transport's own unknown outcome may have reached the space.
+        if (e instanceof ServiceAuthorityTransportError && e.outcome === "unknown")
+            return { outcome: "unconfirmed", ...ids,
+                message: "the space did not confirm the registration request; run the same command again to replay it unchanged" };
+        // Everything else failed before any send. A sign-in the IdP rejected (stock `fetchIdpJwt`'s fixed
+        // 401 sentence; it carries no code) or none at all (`signed-out`) needs a new sign-in.
+        if (e.code === "signed-out" || /rejected the cached session/.test(e.message ?? ""))
+            return { outcome: "not-signed-in", space, message: NOT_SIGNED_IN };
+        return { outcome: "refused", space, message: NOT_SENT };
+    }
+    return registerAnswer(result, ids);
+}
+/** The daemon's outcome for one stock register answer. */
+export function registerAnswer(result, ids) {
+    switch (result.state) {
+        case "approval-required":
+            if (!PROPOSAL_ID.test(result.proposalId))
+                return { outcome: "unconfirmed", ...ids, message: UNUSABLE };
+            return { outcome: "approval-required", ...ids, proposalId: result.proposalId,
+                message: "the space owner must approve this daemon and the space operator must bind its service name; nothing is connected" };
+        case "pending":
+            return { outcome: "pending", ...ids, phase: PHASES.has(result.phase) ? result.phase : UNRECOGNIZED, message: "the space is processing an approved registration; run the same command again" };
+        case "registered": {
+            const w = result.witness;
+            return { outcome: "registered", ...ids,
+                witness: { accountPublicKey: w.accountPublicKey, space: w.space, endpoint: w.endpoint, instanceId: w.instanceId, registrationRevision: w.registrationRevision, processEpoch: w.processEpoch },
+                message: "registered with the space; not activated or serving, so this machine is not connected yet" };
+        }
+        case "denied": {
+            const known = Object.hasOwn(DENIED, result.reason);
+            return { outcome: "refused", ...ids, reason: known ? result.reason : UNRECOGNIZED,
+                message: known ? DENIED[result.reason] : "the space refused the registration for a reason the daemon does not recognize" };
+        }
+        default:
+            return { outcome: "unconfirmed", ...ids, message: UNUSABLE };
+    }
+}

package/dist/daemon/server.js

@@ -16,6 +16,7 @@ import { DAEMON_PROTOCOL_VERSION, MAX_LINE_BYTES, EndpointRefusal, assertLinux,
 import { encode, parseRequest } from "./protocol.js";
 import { createLoginCoordinator } from "./login.js";
 import { connectCheck } from "./connect.js";
+import { registerDaemon } from "./register.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;
@@ -41,7 +42,7 @@ 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 };
+    const counters = { accepted: 0, peerRejected: 0, framesDecoded: 0, requestsRefused: 0, statusAnswered: 0, loginsStarted: 0, loginsRefused: 0, cancelsAnswered: 0, connectChecksAnswered: 0, registersAnswered: 0 };
     const machineHome = opts.sessionDir ?? homeCotalDir();
     const login = opts.login ?? createLoginCoordinator({ sessionDir: machineHome });
     const startedAt = new Date();
@@ -119,6 +120,14 @@ export async function serveDaemon(opts) {
                 });
                 return;
             }
+            if (req.op === "register") {
+                void registerDaemon(req.space, machineHome).catch(() => ({ outcome: "refused", space: req.space, message: "the daemon could not complete the registration request; nothing is connected" }))
+                    .then((result) => {
+                    counters.registersAnswered++;
+                    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++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cotal-ai",
-  "version": "0.95.0",
+  "version": "0.95.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.95.0",
-    "@cotal-ai/cli": "0.95.0",
-    "@cotal-ai/connector-core": "0.95.0",
-    "@cotal-ai/core": "0.95.0",
-    "@cotal-ai/delivery": "0.95.0",
-    "@cotal-ai/manager": "0.95.0",
-    "@cotal-ai/runtime": "0.95.0",
-    "@cotal-ai/seat": "0.95.0",
-    "@cotal-ai/workspace": "0.95.0"
+    "@cotal-ai/auth": "0.95.1",
+    "@cotal-ai/cli": "0.95.1",
+    "@cotal-ai/connector-core": "0.95.1",
+    "@cotal-ai/core": "0.95.1",
+    "@cotal-ai/delivery": "0.95.1",
+    "@cotal-ai/manager": "0.95.1",
+    "@cotal-ai/runtime": "0.95.1",
+    "@cotal-ai/seat": "0.95.1",
+    "@cotal-ai/workspace": "0.95.1"
   },
   "devDependencies": {
-    "@cotal-ai/connector-claude-code": "0.95.0",
-    "@cotal-ai/connector-codex": "0.95.0",
-    "@cotal-ai/connector-hermes": "0.95.0",
-    "@cotal-ai/connector-jcode": "0.95.0",
-    "@cotal-ai/connector-opencode": "0.95.0",
-    "@cotal-ai/linear": "0.95.0",
-    "@cotal-ai/pi": "0.95.0",
+    "@cotal-ai/connector-claude-code": "0.95.1",
+    "@cotal-ai/connector-codex": "0.95.1",
+    "@cotal-ai/connector-hermes": "0.95.1",
+    "@cotal-ai/connector-jcode": "0.95.1",
+    "@cotal-ai/connector-opencode": "0.95.1",
+    "@cotal-ai/linear": "0.95.1",
+    "@cotal-ai/pi": "0.95.1",
     "@cotal-ai/smoke-kit": "0.0.0",
-    "@cotal-ai/web": "0.95.0",
+    "@cotal-ai/web": "0.95.1",
     "@nats-io/jetstream": "^3.4.0",
     "@nats-io/transport-node": "^3.4.0",
     "typescript": "^5.9.3"