@modelprofile.com/authswitch 8.2.0 → 9.0.0

package/dist_ts/ts_migration/legacysources/authswitchstores.js

@@ -189,7 +189,10 @@ export const readAuthSwitchStores = (locations) => {
     catch (error) {
         if (error.code === 'ENOENT')
             return { sources, problems };
-        return { sources, problems: [`${locations.authSwitchHome} could not be listed`] };
+        // The store is named by what it is, never by where it is: this report goes to a CLI and to a backend,
+        // and the location of a credential store is not something either of them may be told. Everything
+        // below names an entry inside the store instead, which is what the owner needs to find it.
+        return { sources, problems: ['the authswitch store could not be listed'] };
     }
     for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
         const path = plugins.path.join(locations.authSwitchHome, entry.name);
@@ -241,4 +244,4 @@ export const readAuthSwitchStores = (locations) => {
     }
     return { sources, problems };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authswitchstores.js","sourceRoot":"","sources":["../../../ts/ts_migration/legacysources/authswitchstores.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authswitchstores.js","sourceRoot":"","sources":["../../../ts/ts_migration/legacysources/authswitchstores.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "8.2.0",
+  "version": "9.0.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -53,10 +53,10 @@
     "authswitch": "./cli.js"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.5.0",
-    "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^6.1.1",
-    "@types/node": "26.5.1",
+    "@git.zone/tsbuild": "^5.0.0",
+    "@git.zone/tsrun": "^3.0.0",
+    "@git.zone/tstest": "^6.2.1",
+    "@types/node": "26.6.1",
     "@types/ws": "8.18.1",
     "esbuild": "^0.28.2",
     "ws": "8.21.2"
@@ -68,9 +68,9 @@
     "@lossless.org/nosqldb": "10.3.0",
     "@modelprofile.com/flexharness-models": "^8.0.0",
     "@modelprofile.com/flexharness-providers": "^8.0.0",
-    "@modelprofile.com/mcp-crossharness": "5.4.0",
+    "@modelprofile.com/mcp-crossharness": "5.5.0",
     "@push.rocks/smartconsole": "^1.3.0",
-    "@push.rocks/smartdaemon": "2.7.0",
+    "@push.rocks/smartdaemon": "2.7.2",
     "@push.rocks/smartsecret": "1.8.0",
     "@types/proper-lockfile": "^4.1.4",
     "proper-lockfile": "^4.1.2"

package/readme.md

@@ -32,7 +32,11 @@ bindings, durable device-operation receipts, Codex enrollment records, and nativ
 owns OpenAI device login, targeted reauthentication, and proactive refresh for grants
 added through this API. Management snapshots expose separate account and login rows,
 including each login's purpose, owner, health, problem and available actions; neither
-snapshots nor events contain credentials.
+snapshots nor events contain credentials. A login that a native tool refreshes also names
+that tool -- `ownerTool` is `claude_code`, `codex` or `opencode`, and `null` exactly when no
+native tool holds it, because the authority refreshes it or nothing does. The authority
+names it rather than leaving a consumer to derive it from the purpose, which would be wrong
+as soon as two purposes share a tool or one tool gains a second purpose.
 
 ```ts
 import { randomUUID } from 'node:crypto';
@@ -51,11 +55,14 @@ const receipt = await client.getOperation(operation.id);
 Browser code can import the credential-free DTOs from
 `@modelprofile.com/authswitch/authority-contract`. The backend-only binding, access and release
 requests are named by `@modelprofile.com/authswitch/authority-runtime-contract`, and the one-time
-import's own DTOs by `@modelprofile.com/authswitch/authority-import-contract`; the runtime contract
-belongs to the runtime socket and its capability must never reach a browser. A backend binds an
-account to a runtime incarnation by exact account ID, login ID and purpose, and keeps the returned
-capability private. Targeted reauthentication likewise requires the exact login; an
-account's presentation default never selects a grant for either action. Completed and
+import's own DTOs by `@modelprofile.com/authswitch/authority-import-contract`; those capabilities must
+never reach a browser. Two of the three runtime requests are served on the runtime socket -- resolving
+access and releasing a binding -- while `authswitch.authority.bind` is served on the **management** socket
+by design: minting a capability is the act that authorizes a runtime, so only a trusted management caller
+may perform it, and a container that is given the runtime directory can use a binding it was handed but can
+never create one. A backend binds an account to a runtime incarnation by exact account ID, login ID and
+purpose, and keeps the returned capability private. Targeted reauthentication likewise requires the
+exact login; an account's presentation default never selects a grant for either action. Completed and
 interrupted operations remain discoverable through `getOperation()` and paged
 `listOperations()`. A completed receipt and its account/grant change commit together, so
 the receipt resolves a lost response or an event that arrives first. Add and reauthentication
@@ -91,9 +98,26 @@ instruction for an owner.
 that marker: it answers `{ code, instruction }` for a refusal and `null` for a fault. The code is the
 closed `TAuthSwitchRefusalCode` set, which is what a client branches on without reading the text:
 `authority_closing`, `not_found`, `account_changed`, `account_busy`, `login_unavailable`,
-`native_owner_holds_login`, `claude_home_unregistered`, `claude_handoff_pending`,
-`claude_receipt_missing` and `import_refusal`. The instruction is authored for the owner and contains no
-path, credential or digest; only an importer refusal may name the process the owner has to stop.
+`binding_unauthorized`, `native_owner_holds_login`, `claude_home_unregistered`, `claude_handoff_pending`,
+`claude_receipt_missing` and `import_refusal`, plus the two the legacy commands answer with on this side of
+the socket, `authority_holds_login` and `authority_unavailable` (see "The legacy fence" below). The
+instruction is authored for the owner and contains no path, credential or digest; only an importer refusal
+may name the process the owner has to stop. The set is producer-owned: a consumer branches on the codes it
+knows and keeps a default branch, which is what lets the authority name a new one without breaking it.
+
+The runtime's own answers are named the same way. `authswitch.authority.bind` refuses `login_unavailable`
+when the authority does not hold the login itself, and `authswitch.authority.resolveAccess` refuses
+`binding_unauthorized` for a capability that authorizes nothing -- missing, wrong, or superseded while the
+credential was being resolved. Those are one answer on purpose: an absent binding and a wrong capability are
+compared against the same zero hash, so nothing distinguishes them, and the repair is the same either way --
+bind again. A binding whose account has since been reauthorized reads `login_unavailable` instead, because
+binding again cannot help until that account holds a login again. A device sign-in or preuse operation this
+authority does not hold reads `not_found`, from whichever route met it. Two things stay unmarked faults on
+purpose. What the shared managed-access loop refuses is one: it serves a bound runtime and the
+credential-free usage reader alike, and those two repair differently. Binding an *account* this authority
+does not hold at all is the other: the storage layer throws `Account is not available for this runtime.`,
+which a socket caller reads as `Internal server error`, because naming it is a decision about which layer
+authors owner instructions rather than a wording fix.
 
 The import routes keep the marker they published in 8.1.0, `authswitch_import_refusal`, and
 `isAuthSwitchImportRefusal` from `@modelprofile.com/authswitch/authority-import-contract` is the same
@@ -259,7 +283,13 @@ native harness process or Codex's app-server is running, and an app-server it ca
 An adopt whose refresh fails, or whose answer is lost, is never retried: the source is quarantined, its grant
 is left needing re-authentication, and the command says so. A projection fails differently, because nothing
 rotating was ever sent for it: a native store that could not be proven live stays a pending native owner and
-is imported by submitting the same source again once its own tool has refreshed it.
+is imported by submitting the same source again once its own tool has refreshed it. That refresh rewrites the
+file, so the retry carries the digest the inventory prints afterwards: a row waiting for its native owner
+follows its own tool's bytes, and nothing else does. What it never follows is another login. A row names the
+account and the grant it was approved for, and a source that now holds a different account's login is refused
+with that stated -- before the account is registered, because the provider read that proves a projection asks
+about the identity the new bytes themselves carry and would prove the wrong login perfectly well. Neither
+that refusal nor "already imported" ever clears: no route forgets a row or re-points it at another account.
 
 `import status` reads the migration ledger, the grants and the handoffs -- never the host -- and reports, per
 source, where it stands, which owner refreshes its login now, and what to do next: nothing, submit the same
@@ -273,6 +303,17 @@ An import deletes nothing: retiring the legacy files is a separate, later step.
 deliberately not backed up, so losing it costs one device sign-in per account -- and the remote-control
 enrollments and runtime bindings with it.
 
+**Where a daemon reads those stores is stated by whoever builds it, never defaulted.** The legacy stores are
+this user's real credentials, and every location they are found at comes from the environment, so
+`AuthSwitchAuthorityDaemon` takes a required `legacyImport`: either the locations to read (an `env` and an
+absolute `homeDirectory`, plus the provider operations that import uses) or `'none'`, which builds a daemon
+with no account import at all and answers `import inventory`, `import status` and `import submit` with the
+`import_refusal` code -- a decided refusal of the closed set, never an empty inventory and never a fault, so
+a caller reads it exactly as it reads every other import refusal. A construction that names neither -- no
+locations and no `'none'` -- is refused before the daemon exists, rather than reading whichever host happened
+to start it. The per-user daemon this package installs -- `authswitch authority daemon`, the service unit's
+own entry point -- is the one place that takes those locations from this host.
+
 `AuthSwitchClient.getUsage(accountId, loginId)` reads OpenAI managed limits or a Claude
 host login's profile and usage through the management socket. The tagged, credential-free
 reading preserves Claude's labelled five-hour, weekly and model windows, plan provenance,
@@ -298,7 +339,7 @@ generated prose and credentials are absent from persistence and management respo
 removal and targeted reauthentication refuse while that account has an active preuse request.
 
 A trusted in-process daemon host can call `AuthSwitchAuthorityDaemon.startManagedCodex()`
-for a bound account and workspace. It owns a private Codex 0.155.1 app-server, passes only
+for a bound account and workspace. It owns a private Codex 0.157.0 app-server, passes only
 the authority's current access token through Codex's external-token login, answers its
 unauthorized callback through the authority, and revokes the binding on stop. The returned
 runtime exposes an interactive `codex --remote unix://…` launch descriptor and native
@@ -314,15 +355,27 @@ gone; an uncertain launch remains blocked. Callers must explicitly stop owned pr
 after their work finishes. Once reauthentication starts, it holds new admissions until the
 device operation settles. Only the private socket directory is removed on close. Codex's
 credential store remains ephemeral and does not read or write `auth.json` in that home.
+Codex binds the app-server socket in its own per-user directory,
+`<realpath /tmp>/codex-daemon-<euid>`, and publishes the private socket path as a link to it.
+The daemon checks that publication with `@modelprofile.com/mcp-crossharness`'s
+`observeCodexUnixSocket` and connects only when the link is exactly Codex's own, in a
+directory other users cannot rewrite, and the socket behind it is the user's own in a 0700
+directory of the user's; anything else fails the start with that package's error. Codex keeps a
+zero-byte startup lock in that directory for each socket path it has served; the file is
+Codex's own and authswitch does not remove it.
+Managed Codex runs only the verified Codex release: a `codex` that reports any other
+version is refused before it starts, so an automatic Codex update stops new managed
+sessions until authswitch has verified that release.
 Managed-Codex process ownership observation is qualified on Linux and reads exact argument
 boundaries from `/proc`; on other hosts doctor reports the process observation as unknown,
 and authority actions that require survivor proof refuse instead of guessing.
-Codex 0.155.1 does not persist an unused thread created by `thread/start`; resume applies
+Codex 0.157.0 does not persist an unused thread created by `thread/start`; resume applies
 after Codex has committed a rollout. The existing CLI has not yet been moved to this path.
 
 This SDK is additive at this stage. The commands documented below still use the existing
-credential stores. The authority daemon does not import those stores automatically,
-replace their active native sessions, or take over their refresh grants. An active
+credential stores, except that the legacy fence below refuses them a login the authority
+holds. The authority daemon does not import those stores automatically, replace their
+active native sessions, or take over their refresh grants. An active
 Codex/OpenCode native grant remains pending until its owner is idle and an explicit
 handoff verifies the latest native source. Claude Code's own native credential files
 remain vendor-owned; a container setup-token grant is a separate grant under the same
@@ -353,6 +406,62 @@ restore system could have written.
 The store is deliberately not backed up: its refresh grants are sealed to this host's TPM,
 so a lost store is recovered by one device re-login per account.
 
+### The legacy fence
+
+Once the authority has taken a saved copy over, the legacy `save` and `switch` must not write it again: an
+adopted copy's refresh token was rotated away by the import, and activating it would hand a tool a dead
+login. `runAuthSwitchMutation` -- the one path the command line, the guide, `watch` and the hosted
+`AuthSwitchService` all take -- asks first, and decides in three branches.
+
+- **The authority answers**: it is asked for this record's ledger row through `import status` on the
+  management socket, keyed by the same source id the importer uses (a hash of the saved copy's path). A
+  `verified` or `complete` row refuses with `authority_holds_login`; any other row, or none, lets the command
+  run. An authority that answers decides, whether or not its service unit is installed.
+- **Nothing answers within four seconds -- no socket, a silent one, or no `XDG_RUNTIME_DIR` -- and the
+  authority's service unit is installed**: the command refuses with `authority_unavailable` and the
+  instruction to run `authswitch authority service start`. Unknown is never treated as idle.
+- **Nothing answers and no unit is installed**: the legacy commands behave exactly as before. This is every
+  host before the cutover.
+
+What tells the second branch from the third is durable, never the socket: the runtime directory is tmpfs,
+so after a reboot the socket is absent until the user service starts -- exactly when a fence keyed on it
+would open. The evidence is the unit `authswitch authority service install` writes,
+`$XDG_DATA_HOME/systemd/user/authswitch-authority.service` (default
+`~/.local/share/systemd/user/authswitch-authority.service`), read through smartdaemon's
+`SystemdUnitFile.inspect()`. The installer and the fence derive that directory from one rule,
+`$XDG_DATA_HOME` or else the home directory; the installer takes both from its own process and its account's
+home, the fence from the locations its caller states. The two agree unless `$HOME` is overridden while
+`XDG_DATA_HOME` is unset, and then every store the fence guards lies under that overridden home too. The fence
+writes nothing and keeps no record of its own.
+
+The check works without a login session. Reading the unit needs only its directory, so a cron job or a plain
+ssh command with no `XDG_RUNTIME_DIR` is decided by the unit exactly like a desktop session: no unit, the
+legacy commands run; the unit installed, they refuse with `authority_unavailable`. The stated
+`XDG_RUNTIME_DIR` names only the socket to ask; an absent one is never replaced by this process's own. The
+answer depends on the unit directory derived from the stated `XDG_DATA_HOME` or home, and on nothing else:
+a malformed `XDG_RUNTIME_DIR` or `XDG_CONFIG_HOME` never refuses the command, and neither does a malformed
+process `XDG_DATA_HOME` when the caller states other locations. A unit that cannot be inspected -- a file the
+installer would not have written, a directory another user can write -- refuses rather than being read as
+absent, and so does a stated `XDG_DATA_HOME` that names no usable unit directory, because the reader can
+then tell an installed authority from none no better. On a platform without systemd no unit can be
+installed.
+
+The unit says an authority exists, not which stores it imports from, so while an installed authority is
+stopped the legacy save and switch refuse for every saved copy of every store, until it runs again. A
+record the importer could never have read -- an account id that names no saved-copy file -- is never asked
+about.
+
+`drop` / `rm` and the `remove` mutation are deliberately not fenced: they delete the user's own saved copy
+and write no credential. A projected source is never fenced either -- its native store stays with its own
+tool. The command line takes this host's locations only when it composes its own harnesses, and with
+injected harnesses is fenced only by locations its caller states; `AuthSwitchOperations`,
+`runAuthSwitchMutation` and an `AuthSwitchService` given its harnesses take the locations as a required
+argument (`authSwitchHostLegacyFence()` names this host's, `'none'` states that a
+caller owns no authority), so no library path reads a host it was not given. `AuthSwitchOperations` and the
+hosted service ask the fence before their AGL coordinator as well, so a refused mutation never has its host
+stop the runtimes it would restart. The hosted service reports a fence refusal as the operation's problem, in
+the instruction's own words.
+
 ## Usage
 
 Run `authswitch`, `authswitch -i`, or `authswitch --interactive` for an interactive guide. Use the arrow keys and
@@ -515,9 +624,12 @@ login. `activateCredential(providerId, credential)` preserves and verifies the
 outgoing native login before activation; the caller retains ownership of the
 incoming credential's durable storage. Both are backend APIs, never wire payloads.
 
-`AuthSwitchOperations` is shared by the command, guide and TUI. Its optional
-coordinator receives only the harness, operation, account ID, consent to wait,
-and a credential-location fingerprint. AGL owns private-controller discovery;
+`AuthSwitchOperations` is shared by the command, guide and TUI, and is built
+with a coordinator (or `undefined`) and the legacy fence locations described in
+"The legacy fence". A host that injects its own harnesses into `AuthSwitchService`
+states that fence as the third argument. The coordinator receives only the
+harness, operation, account ID, consent to wait, and a credential-location
+fingerprint. AGL owns private-controller discovery;
 authswitch uses `agl authswitch --request <json>` without an AGL package dependency.
 A failed or ambiguous transport never falls through to a second local mutation.
 AGL and the CLI must use matching credential locations and compatible versions.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '8.2.0',
+  version: '9.0.0',
   description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/authority-contract.ts

@@ -15,6 +15,12 @@ export type TAuthSwitchRefusalCode =
   | 'account_changed'
   | 'account_busy'
   | 'login_unavailable'
+  /** A runtime capability that is missing, wrong or superseded: deliberately one answer, and one repair. */
+  | 'binding_unauthorized'
+  /** The authority holds this login, so the legacy path that used to move it no longer may. */
+  | 'authority_holds_login'
+  /** An authority is installed on this host and is not answering, so nothing may assume it holds nothing. */
+  | 'authority_unavailable'
   | 'native_owner_holds_login'
   | 'claude_home_unregistered'
   | 'claude_handoff_pending'
@@ -42,8 +48,9 @@ export interface IAuthSwitchRefusal {
 
 const refusalCodes: ReadonlySet<string> = new Set<TAuthSwitchRefusalCode>([
   'authority_closing', 'not_found', 'account_changed', 'account_busy',
-  'login_unavailable', 'native_owner_holds_login', 'claude_home_unregistered',
+  'login_unavailable', 'binding_unauthorized', 'native_owner_holds_login', 'claude_home_unregistered',
   'claude_handoff_pending', 'claude_receipt_missing', 'import_refusal',
+  'authority_holds_login', 'authority_unavailable',
 ]);
 
 const isRefusalCode = (value: unknown): value is TAuthSwitchRefusalCode =>
@@ -110,6 +117,16 @@ export interface IAuthSwitchAccount {
   statusObservedAt: string;
 }
 
+/**
+ * Which tool refreshes a natively owned login, named rather than inferred.
+ *
+ * `owner` says that a native tool holds the login; this says which one, so a consumer presents "Claude Code"
+ * or "Codex" without deriving it from `purpose` -- a derivation that would be wrong the moment two purposes
+ * share a tool, and that belongs to the side that decides ownership in the first place. It is `null` exactly
+ * when no native tool refreshes the login: the authority does, or nothing does.
+ */
+export type TAuthSwitchLoginOwnerTool = 'claude_code' | 'codex' | 'opencode';
+
 /** One independently owned login. Native ownership does not imply observed health. */
 export interface IAuthSwitchLogin {
   id: string;
@@ -117,6 +134,8 @@ export interface IAuthSwitchLogin {
   providerId: string;
   purpose: TAuthSwitchLoginPurpose;
   owner: 'daemon' | 'claude_native' | 'legacy_native' | 'none';
+  /** The native tool that refreshes this login, or null when the authority or nobody does. */
+  ownerTool: TAuthSwitchLoginOwnerTool | null;
   health: TAuthSwitchLoginHealth;
   problem: 'none' | 'provider_unavailable' | 'exchange_uncertain' | 'provider_rejected' | 'native_owner';
   grantGeneration: number;

package/ts/authority-paths.ts

@@ -0,0 +1,69 @@
+import * as plugins from './plugins.js';
+
+/**
+ * Where this user's authority lives: its sockets, its store and the service unit that runs it.
+ *
+ * These rules sit in a leaf module because two sides read them. `AuthSwitchAuthorityService` installs and
+ * runs the daemon there, and the legacy fence (`./classes.legacyfence`) asks the same socket and looks for
+ * the same unit -- without importing the daemon, whose module graph reaches back to the legacy operations
+ * the fence guards.
+ */
+
+export interface IAuthSwitchAuthorityPaths {
+  runtimeDirectory: string;
+  dataDirectory: string;
+  databaseSocketPath: string;
+  authoritySocketPath: string;
+  runtimeSocketPath: string;
+  runtimeSocketDirectory: string;
+}
+
+/** The authority's sockets. */
+export type TAuthSwitchAuthoritySocketPaths = Omit<IAuthSwitchAuthorityPaths, 'dataDirectory'>;
+
+/**
+ * The sockets under one runtime directory, derived from it alone.
+ *
+ * The legacy fence asks the socket a caller states and must not depend on anything this process holds --
+ * its home or its `XDG_DATA_HOME`, which only the store's directory needs.
+ */
+export const authSwitchAuthoritySocketPaths = (
+  runtimeDirectory: string | undefined): TAuthSwitchAuthoritySocketPaths => {
+  if (!runtimeDirectory || !plugins.path.isAbsolute(runtimeDirectory)) {
+    throw new Error('A private XDG_RUNTIME_DIR is required for authswitch authority.');
+  }
+  const socketDirectory = plugins.path.join(runtimeDirectory, 'authswitch');
+  const runtimeSocketDirectory = plugins.path.join(socketDirectory, 'runtime');
+  return {
+    runtimeDirectory,
+    databaseSocketPath: plugins.path.join(socketDirectory, 'internal', 'db.sock'),
+    authoritySocketPath: plugins.path.join(socketDirectory, 'management', 'authority.sock'),
+    runtimeSocketPath: plugins.path.join(runtimeSocketDirectory, 'runtime.sock'),
+    runtimeSocketDirectory,
+  };
+};
+
+/** Canonical per-user paths. An explicit runtime directory is also usable by a trusted container host. */
+export const resolveAuthSwitchAuthorityPaths = (runtimeDirectory = process.env.XDG_RUNTIME_DIR): IAuthSwitchAuthorityPaths => {
+  const sockets = authSwitchAuthoritySocketPaths(runtimeDirectory);
+  const home = plugins.os.userInfo().homedir;
+  const dataHome = process.env.XDG_DATA_HOME || plugins.path.join(home, '.local/share');
+  if (!plugins.path.isAbsolute(dataHome)) throw new Error('XDG_DATA_HOME must be an absolute path.');
+  return { ...sockets, dataDirectory: plugins.path.join(dataHome, 'authswitch', 'authority') };
+};
+
+/** The user service `authswitch authority service install` writes. */
+export const authSwitchAuthorityUnitName = 'authswitch-authority.service';
+
+/**
+ * The directory that unit is installed into, from a stated environment and home directory.
+ *
+ * It is the rule smartdaemon applies to a user unit when it is given no directory --
+ * `$XDG_DATA_HOME/systemd/user`, default `~/.local/share/systemd/user` -- stated here so the installer passes
+ * it explicitly and the fence derives it from the locations its caller states rather than from this process.
+ */
+export const authSwitchAuthorityUnitDirectory = (env: NodeJS.ProcessEnv, homeDirectory: string): string => {
+  const dataHome = env.XDG_DATA_HOME || plugins.path.join(homeDirectory, '.local/share');
+  if (!plugins.path.isAbsolute(dataHome)) throw new Error('XDG_DATA_HOME must be an absolute path.');
+  return plugins.path.join(dataHome, 'systemd/user');
+};

package/ts/authority-runtime-contract.ts

@@ -1,7 +1,17 @@
 import type { ITypedRequest } from '@api.global/typedrequest-interfaces';
 import type { IAuthSwitchBinding } from './authority-contract.js';
 
-/** Backend-only binding operation. The capability must never enter a browser-facing response. */
+/**
+ * Backend-only binding operation, served on the MANAGEMENT socket. Not a misplacement -- the rule.
+ *
+ * The other two requests in this file are answered on the runtime socket, whose directory a container may
+ * be given. This one is not, because it mints the capability those two spend: minting is the act that
+ * authorizes a runtime, so it belongs to a caller already trusted with account management. A container
+ * holding the runtime directory can therefore use the binding it was handed, and can never create one --
+ * not for itself, and not for another account.
+ *
+ * The capability must never enter a browser-facing response.
+ */
 export interface IReq_AuthSwitchBindAccount extends ITypedRequest {
   method: 'authswitch.authority.bind';
   request: {