@consiliency/agent-board-cli 1.33.0 → 1.34.0

package/claude-marketplace/plugins/agent-board/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-board",
-  "version": "1.37.0",
+  "version": "1.38.0",
   "description": "Message Board for Claude Code: the agent-board MCP server and the local wake hook that nudges an idle session when its inbox has unhandled items.",
   "author": {
     "name": "Consiliency"
@@ -10,7 +10,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@consiliency/agent-board-mcp@1.37.0",
+        "@consiliency/agent-board-mcp@1.38.0",
         "--harness",
         "claude"
       ]

package/dist/assets.json

@@ -1,6 +1,6 @@
 {
-  "mcpVersion": "1.37.0",
-  "piVersion": "0.5.1",
-  "opencodeVersion": "0.3.1",
-  "releaseTag": "v1.63.0"
+  "mcpVersion": "1.38.0",
+  "piVersion": "0.5.2",
+  "opencodeVersion": "0.3.2",
+  "releaseTag": "v1.64.0"
 }

package/dist/cli.d.ts

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { createAgentBoardClient, type EnrollKeystore, type EnrollmentIntent, type FleetOnboardingIntent, type PendingEnrollmentStore, type OAuthFetchLike, type FetchLike, type AgentJoinDeployment, type AgentJoinInstructions, type DeviceAuthorizationPrompt, resolveCredentials, type MyBoardRequest } from "@consiliency/agent-board-client";
 import { type DoctorOptions, type DoctorReport } from "./doctor.js";
+import { type SessionOwnerCommandOptions } from "./session_owner_commands.js";
 import { type SetupEnroller, type SetupRunner } from "./setup.js";
 import { type SetupAllRunner } from "./setup_all.js";
 import { DevicePendingEnrollmentStore } from "./enroll_runtime.js";
@@ -64,6 +65,13 @@ interface ClientLike {
         instructions: AgentJoinInstructions;
     }>;
     revokeInviteLink(input: JsonObject): Promise<unknown>;
+    renameAgent(input: {
+        agentId: string;
+        displayName: string;
+    }): Promise<unknown>;
+    revokeSessionIdentity(input: {
+        identityAgentId: string;
+    }): Promise<unknown>;
     redeemInviteLink(input: JsonObject): Promise<unknown>;
     listMyBoardRequests(): Promise<MyBoardRequest[]>;
     listBoardMembers(input: JsonObject): Promise<unknown>;
@@ -334,8 +342,8 @@ export interface CredentialSelection {
  * doctor does, because `--as` is an explicit choice of the file. The runtime descriptor is ignored
  * for the same reason. Without it: `resolveCredentials(descriptor, env)`, exactly as before.
  */
-export declare function fileAwareCredentials(selection: CredentialSelection, env?: NodeJS.ProcessEnv): (descriptor?: Parameters<typeof resolveCredentials>[0]) => Promise<import("@consiliency/agent-board-client").ResolvedCredentials>;
-export declare function createProgram(client: ClientLike, io: CliIo, enrollment?: EnrollmentCommandRunner, doctor?: DoctorRunner, selection?: CredentialSelection, setup?: SetupRunner, setupAll?: SetupAllRunner): Command;
+export declare function fileAwareCredentials(selection: CredentialSelection, env?: NodeJS.ProcessEnv, loaded?: (credentials: Awaited<ReturnType<typeof resolveCredentials>>, selectedEnv: NodeJS.ProcessEnv) => void): (descriptor?: Parameters<typeof resolveCredentials>[0]) => Promise<import("@consiliency/agent-board-client").ResolvedCredentials>;
+export declare function createProgram(client: ClientLike, io: CliIo, enrollment?: EnrollmentCommandRunner, doctor?: DoctorRunner, selection?: CredentialSelection, setup?: SetupRunner, setupAll?: SetupAllRunner, sessionOwner?: SessionOwnerCommandOptions): Command;
 export interface RunCliOptions {
     /** The env the default client's credential resolver reads. Default `process.env`. */
     env?: NodeJS.ProcessEnv;
@@ -343,6 +351,7 @@ export interface RunCliOptions {
     clientOptions?: Omit<NonNullable<Parameters<typeof createAgentBoardClient>[0]>, "resolveCredentials">;
     setup?: SetupRunner;
     setupAll?: SetupAllRunner;
+    sessionOwner?: SessionOwnerCommandOptions;
 }
 export declare function runCli(argv: string[], io?: CliIo, client?: ClientLike, enrollment?: EnrollmentCommandRunner, doctor?: DoctorRunner, options?: RunCliOptions): Promise<void>;
 export {};

package/dist/cli.js

@@ -1,10 +1,11 @@
-import { Command, Option } from "commander";
+import { Command, InvalidArgumentError, Option } from "commander";
 import { createHash, randomUUID } from "node:crypto";
 import * as nodeFs from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createAgentBoardClient, toOperationFailure, beginEnrollment, completeEnrollment, beginDeviceEnrollment, completeDeviceEnrollment, runEnrollment, runDeviceEnrollment, resolveEnrollmentDescriptor, EnrollmentDescriptorError, EnrollmentCommandError, resolveEnrollEndpoint, resolveEnrollSessionUrl, resolveEnrollPublishableKey, resolveJoinDeployment, buildFleetHarnessTemplate, finalizeFleetHarnessTemplate, normalizePublishableKeyFieldReference, normalizeFleetTupleValue, normalizeKeyReference, enrollCommitMarker, assertPresentationSafe, FLEET_TEMPLATE_FAILURE_MESSAGE, PROHIBITED_PRESENTATION_REMOVE_CLASS, buildAgentJoinInstructions, nodeFetchAdapter, buildEnrollKeystore, AUTHORED_CAUSE_CODES, codeProvenance, markAuthoredCode, assertIdentityHarness, identityFilePath, resolveHostSegment, identityConfigRoot, walkTrustedDirectory, IDENTITY_HARNESSES, CredentialResolutionError, readIdentityFile, resolveCredentials, parseInviteInput, } from "@consiliency/agent-board-client";
 import { fileIdentityEnv, formatDoctorReport, runDoctor } from "./doctor.js";
+import { addSessionOwnerCommands, sessionOwnerContext } from "./session_owner_commands.js";
 import { addSetupCommand, runSetup } from "./setup.js";
 import { runSetupAll, setupAllCommand } from "./setup_all.js";
 import { identityValuesFromEnrollment, resolveIdentityDeployment, writeIdentityFile, } from "./identity_writer.js";
@@ -479,7 +480,30 @@ function recipientOption(flags, description) {
         return parsed;
     });
 }
+const SIDCLI_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sidcliUuid(value) {
+    if (!SIDCLI_UUID.test(value))
+        throw new InvalidArgumentError("identifier must be a UUID");
+    return value;
+}
+function sidcliDisplayName(value) {
+    // Match the RPC's space-only blank rule while preserving valid text exactly.
+    if (/^ *$/.test(value))
+        throw new InvalidArgumentError("display name is required");
+    return value;
+}
 function addWriteCommands(program, client, io) {
+    program
+        .command("rename")
+        .description("Rename an agent's display name (human owner credentials required)")
+        .requiredOption("--agent-id <uuid>", "target agent UUID", sidcliUuid)
+        .requiredOption("--display-name <text>", "new nonblank display name", sidcliDisplayName)
+        .action((o) => runHandler(io, "agent_board.rename_agent", () => client.renameAgent({ agentId: o.agentId, displayName: o.displayName })));
+    program
+        .command("revoke-child")
+        .description("Revoke a session identity and its descendants and transitive forks. Already-issued session tokens remain bounded by their existing 900-second lifetime.")
+        .requiredOption("--identity-agent-id <uuid>", "session identity UUID", sidcliUuid)
+        .action((o) => runHandler(io, "agent_board.revoke_session_identity", () => client.revokeSessionIdentity({ identityAgentId: o.identityAgentId })));
     program
         .command("resolve-recipients")
         .option("--actor-agent-id <agentId>")
@@ -3246,17 +3270,23 @@ function addDoctorCommand(program, io, doctor) {
  * doctor does, because `--as` is an explicit choice of the file. The runtime descriptor is ignored
  * for the same reason. Without it: `resolveCredentials(descriptor, env)`, exactly as before.
  */
-export function fileAwareCredentials(selection, env = process.env) {
+export function fileAwareCredentials(selection, env = process.env, loaded) {
     return async (descriptor) => {
         const harness = selection.as;
-        if (harness === undefined)
-            return resolveCredentials(descriptor, env);
+        if (harness === undefined) {
+            const credentials = await resolveCredentials(descriptor, env);
+            loaded?.(credentials, env);
+            return credentials;
+        }
         assertIdentityHarness(harness);
         const { values } = await readIdentityFile({ harness, env });
-        return resolveCredentials(undefined, fileIdentityEnv(env, values));
+        const selectedEnv = fileIdentityEnv(env, values);
+        const credentials = await resolveCredentials(undefined, selectedEnv);
+        loaded?.(credentials, selectedEnv);
+        return credentials;
     };
 }
-export function createProgram(client, io, enrollment = defaultEnrollmentRunner(), doctor = runDoctor, selection = {}, setup, setupAll) {
+export function createProgram(client, io, enrollment = defaultEnrollmentRunner(), doctor = runDoctor, selection = {}, setup, setupAll, sessionOwner) {
     const program = new Command()
         .name("agent-board")
         .description("Thin CLI surface for the agent_board RPC and canonical read contracts")
@@ -3283,6 +3313,9 @@ export function createProgram(client, io, enrollment = defaultEnrollmentRunner()
         .action((options) => runRuntimeDoctor(io, client, Boolean(options.requireRuntime)));
     addWriteCommands(program, client, io);
     addReadCommands(program, client, io);
+    addSessionOwnerCommands(program, client, io, (operation, action) => runHandler(io, operation, action), sessionOwner ?? {
+        loadContext: async () => { throw new CredentialResolutionError("identity_context_unavailable", "Loaded identity context is required; no ambient identity fallback is allowed"); },
+    });
     addRoomsCommands(program, client, io);
     addInviteCommands(program, client, io);
     addEnrollCommands(program, io, enrollment);
@@ -3295,11 +3328,22 @@ export async function runCli(argv, io = {
     writeStderr: (message) => process.stderr.write(message),
 }, client, enrollment = defaultEnrollmentRunner(), doctor = runDoctor, options = {}) {
     const selection = {};
+    let ownerContext;
     // Built BEFORE parsing, as always; `--as` reaches it through `selection` at first use.
     const resolved = client ?? createAgentBoardClient({
         ...options.clientOptions,
-        resolveCredentials: fileAwareCredentials(selection, options.env ?? process.env),
+        resolveCredentials: fileAwareCredentials(selection, options.env ?? process.env, (credentials, env) => {
+            ownerContext = () => sessionOwnerContext(credentials, env, selection.as);
+        }),
     });
-    const program = createProgram(resolved, io, enrollment, doctor, selection, options.setup, options.setupAll);
+    const program = createProgram(resolved, io, enrollment, doctor, selection, options.setup, options.setupAll, options.sessionOwner ?? (client ? undefined : {
+        loadContext: async () => {
+            // Non-minting: approval must remain usable when the agent root is frozen.
+            await resolved.credentialMode();
+            if (!ownerContext)
+                throw new CredentialResolutionError("identity_context_unavailable", "Loaded identity context is unavailable");
+            return ownerContext();
+        },
+    }));
     await program.parseAsync(argv, { from: "user" });
 }

package/dist/session_owner_commands.d.ts

@@ -0,0 +1,22 @@
+import type { Command } from "commander";
+import { type AgentBoardClient, type ResolvedCredentials, type IdentityHarness, type SessionFingerprintResult } from "@consiliency/agent-board-client";
+type OwnerClient = Pick<AgentBoardClient, "whoami" | "resolveAgentHandle" | "listSessionChildren" | "getSessionIdentityState" | "approveIdentityStateViaRelay" | "recordOwnIdentityStateViaRelay">;
+export interface SessionOwnerContext {
+    boardUrl: string;
+    publishableKey: string;
+    harness?: IdentityHarness;
+    env: NodeJS.ProcessEnv;
+}
+export interface SessionOwnerCommandOptions {
+    loadContext(): Promise<SessionOwnerContext>;
+    signHuman?(context: SessionOwnerContext): Promise<OwnerClient>;
+    confirmFreeze?(): Promise<boolean>;
+    readFingerprint?(context: SessionOwnerContext & {
+        harness: IdentityHarness;
+    }): SessionFingerprintResult;
+}
+export declare function sessionOwnerContext(credentials: ResolvedCredentials, env: NodeJS.ProcessEnv, selectedHarness?: string): SessionOwnerContext;
+export declare function addSessionOwnerCommands(program: Command, client: OwnerClient, io: {
+    writeStderr(message: string): void;
+}, run: (operation: string, action: () => Promise<unknown>) => Promise<void>, options: SessionOwnerCommandOptions): void;
+export {};

package/dist/session_owner_commands.js

@@ -0,0 +1,94 @@
+import { createInterface } from "node:readline/promises";
+import { homedir } from "node:os";
+import { acquireHumanSession, resolveEnrollmentDescriptor, readSessionFingerprint, assertIdentityHarness, SessionError, } from "@consiliency/agent-board-client";
+export function sessionOwnerContext(credentials, env, selectedHarness) {
+    if (credentials.mode === "service_role")
+        throw new SessionError("identity_relay_caller_required", "Caller credentials are required");
+    const declared = selectedHarness ?? env.MESSAGE_BOARD_WAKE_HARNESS_KIND;
+    if (declared !== undefined)
+        assertIdentityHarness(declared);
+    const boardUrl = credentials.mode === "keystore_session" ? credentials.descriptor.boardUrl : credentials.url;
+    const publishableKey = credentials.mode === "keystore_session" ? credentials.descriptor.publishableKey : credentials.publishableKey;
+    if (!publishableKey)
+        throw new SessionError("missing_publishable_key", "Configured board publishable key is required");
+    return { boardUrl, publishableKey, harness: declared, env: { ...env } };
+}
+const uuid = (value) => /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(value);
+async function identityId(client, value) {
+    if (uuid(value))
+        return value;
+    const row = await client.resolveAgentHandle({ p_handle: value });
+    if (!row || typeof row.agent_id !== "string")
+        throw new SessionError("identity_read_forbidden", "Identity reading is not authorized");
+    return row.agent_id;
+}
+export function addSessionOwnerCommands(program, client, io, run, options) {
+    const signHuman = options.signHuman ?? (async (context) => {
+        const descriptor = resolveEnrollmentDescriptor(context.env, { keyReference: "os_keychain:human-session-unused" });
+        descriptor.boardUrl = context.boardUrl;
+        return acquireHumanSession({ descriptor, publishableKey: context.publishableKey, device: {
+                onDeviceAuthorization: prompt => io.writeStderr(`Human owner sign-in: ${prompt.verificationUri} code ${prompt.userCode}\n`),
+            } });
+    });
+    program.command("children <parent>").description("List authorized strict session descendants as JSON")
+        .action(parent => run("agent_board.list_session_children", async () => client.listSessionChildren({ p_parent_agent_id: await identityId(client, parent) })));
+    program.command("approve <identity>").description("Human-owner compare-and-approve of a stored identity reading")
+        .requiredOption("--digest <expected-digest>")
+        .action((identity, flags) => run("agent_board.approve_identity_state", async () => {
+        if (!/^[0-9a-f]{64}$/.test(flags.digest))
+            throw new SessionError("identity_digest_invalid", "Expected digest must be a SHA-256 digest");
+        const human = await signHuman(await options.loadContext());
+        const target = await identityId(human, identity);
+        const [state] = await human.getSessionIdentityState({ p_identity_agent_id: target });
+        if (!state)
+            throw new SessionError("identity_read_forbidden", "Identity reading is not authorized");
+        io.writeStderr(JSON.stringify({ identity_agent_id: target, fingerprint_resolution: state.fingerprint_resolution,
+            recorded_fingerprint: state.recorded_fingerprint, current_risky_digest: state.current_risky_digest, expected_digest: flags.digest }) + "\n");
+        return human.approveIdentityStateViaRelay({ identity_agent_id: target, risky_digest: flags.digest });
+    }));
+    program.command("fingerprint").description("Deliberate self-reported depth-0 identity readings")
+        .command("record").option("--acknowledge-freeze", "acknowledge that recording freezes minting until owner approval")
+        .action(flags => run("agent_board.record_session_identity_state", async () => {
+        io.writeStderr("Recording freezes new token minting until human-owner approval. The current token lasts at most 900 seconds.\n");
+        let acknowledged = flags.acknowledgeFreeze === true;
+        if (!acknowledged) {
+            if (options.confirmFreeze)
+                acknowledged = await options.confirmFreeze();
+            else if (process.stdin.isTTY) {
+                const terminal = createInterface({ input: process.stdin, output: process.stderr });
+                try {
+                    acknowledged = (await terminal.question("Acknowledge the freeze? Type yes: ")).trim() === "yes";
+                }
+                finally {
+                    terminal.close();
+                }
+            }
+        }
+        if (!acknowledged)
+            throw new SessionError("identity_freeze_acknowledgement_required", "Explicit freeze acknowledgement is required");
+        const context = await options.loadContext();
+        if (!context.harness)
+            throw new SessionError("identity_harness_required", "Select the loaded identity harness with --as");
+        const actor = (await client.whoami()).credentials.session?.actingAgentId;
+        if (!actor)
+            throw new SessionError("agent_identity_unresolved", "The loaded agent identity is unresolved");
+        const [root] = await client.getSessionIdentityState({ p_identity_agent_id: actor });
+        if (!root || root.depth !== 0 || root.root_agent_id !== actor)
+            throw new SessionError("identity_record_forbidden", "Only the loaded depth-0 agent may record");
+        const human = await signHuman(context);
+        try {
+            // N1: an empty subtree is allowed only after SQL checks root ownership.
+            await human.listSessionChildren({ p_parent_agent_id: actor });
+            const [ownedRoot] = await human.getSessionIdentityState({ p_identity_agent_id: actor });
+            if (!ownedRoot || ownedRoot.agent_id !== actor || ownedRoot.depth !== 0)
+                throw new Error("owner reading absent");
+        }
+        catch {
+            throw new SessionError("identity_human_owner_required", "No signed-in human owner can read this root; nothing was recorded");
+        }
+        const fingerprint = options.readFingerprint ? options.readFingerprint({ ...context, harness: context.harness }) : readSessionFingerprint({
+            harness: context.harness, home: context.env.HOME ?? homedir(), cwd: process.cwd(), env: context.env,
+        });
+        return client.recordOwnIdentityStateViaRelay({ fingerprint });
+    }));
+}

package/keyslot/lib.sh

@@ -272,7 +272,7 @@ function ed25519FromWire(wire) {
 }
 
 // Classify one PEM block for the scan: "match", "nomatch", "encrypted" or "unverifiable".
-function classifyBlock(kind, body, pin) {
+function classifyBlock(kind, body, pin, sessionChild = false) {
   if (kind === "OPENSSH PRIVATE KEY") {
     if (!/^[A-Za-z0-9+/=\s]+$/.test(body)) return "unverifiable";
     const buf = Buffer.from(body.replace(/\s+/g, ""), "base64");
@@ -291,7 +291,7 @@ function classifyBlock(kind, body, pin) {
       const pubs = [];
       for (let i = 0; i < n; i++) { let w; [w, off] = sshString(buf, off); pubs.push(w); }
       if (cipher.toString() !== "none") return "encrypted";
-      for (const w of pubs) { if (ed25519FromWire(w) === pin && pin) return "match"; }
+      for (const w of pubs) { if (sessionChild ? ed25519FromWire(w) !== null : ed25519FromWire(w) === pin && pin) return "match"; }
       return "nomatch";
     } catch { return "unverifiable"; }
   }
@@ -299,7 +299,7 @@ function classifyBlock(kind, body, pin) {
   try {
     const key = crypto.createPrivateKey({ key: `-----BEGIN PRIVATE KEY-----\n${body}\n-----END PRIVATE KEY-----\n`, format: "pem" });
     if (key.asymmetricKeyType !== "ed25519") return "nomatch";
-    return pin && crypto.createPublicKey(key).export({ format: "jwk" }).x === pin ? "match" : "nomatch";
+    return sessionChild || (pin && crypto.createPublicKey(key).export({ format: "jwk" }).x === pin) ? "match" : "nomatch";
   } catch { return "unverifiable"; }
 }
 
@@ -457,7 +457,10 @@ if (mode === "derive") {
       if (!m) continue;
       const end = lines.indexOf(`-----END ${m[1]}-----`, i + 1);
       if (end < 0) { verdicts.add("unverifiable"); continue; }
-      verdicts.add(classifyBlock(m[1], lines.slice(i + 1, end).join("\n"), pin));
+      // Session children have different public keys from the machine's parent pin.
+      // No unencrypted child is an allowed copy, even when it does not match that pin.
+      verdicts.add(classifyBlock(m[1], lines.slice(i + 1, end).join("\n"), pin,
+        p.includes("/agent-board/session-keys/")));
       i = end;
     }
     if (verdicts.size === 0) continue;
@@ -669,6 +672,13 @@ keyseal_scan_roots() {
   local r real skipped= seen
   local -a declared
   declared=("$HOME" "$XDG_RUNTIME_DIR" "${TMPDIR:-/tmp}" /tmp /var/tmp)
+  # SIDCLIENT: a relocated XDG child store may be outside HOME (or beneath a
+  # pruned ancestor). Give its existing subtree an independent starting point.
+  local config=${XDG_CONFIG_HOME-}
+  [[ -n ${config//[[:space:]]/} ]] || config=$HOME/.config
+  if [[ $config == /* && $config != "$HOME/.config" && -d $config/agent-board/session-keys ]]; then
+    declared+=("$config/agent-board/session-keys")
+  fi
   KEYSEAL_ROOTS=()
   for r in "${declared[@]}"; do
     if ! real=$("$KEYSEAL_BIN_REALPATH" -e -- "$r" 2>/dev/null) || [[ ! -d $real ]]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consiliency/agent-board-cli",
-  "version": "1.33.0",
+  "version": "1.34.0",
   "repository": "https://github.com/Consiliency/message-board.git",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +33,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@consiliency/agent-board-client": "1.45.0",
+    "@consiliency/agent-board-client": "1.46.0",
     "commander": "^14.0.1"
   },
   "license": "Apache-2.0",