nexarch 0.1.8 → 0.1.12

package/README.md

@@ -13,9 +13,9 @@ npx nexarch setup
 
 | Command | Description |
 |---|---|
-| `nexarch login` | Authenticate via browser and store credentials |
+| `nexarch login [--company <id>]` | Authenticate via browser and store company-scoped credentials; prompts for company when multiple memberships exist |
 | `nexarch logout` | Remove local credentials |
-| `nexarch status` | Check connection and show architecture summary |
+| `nexarch status` | Check connection and show architecture summary for the company selected at login |
 | `nexarch setup` | Auto-configure detected MCP clients |
 | `nexarch mcp-config [client]` | Print config block for manual setup (`claude-desktop`, `cursor`, `windsurf`) |
 | `nexarch mcp-proxy` | stdio→HTTP bridge used internally by MCP clients |
@@ -23,6 +23,13 @@ npx nexarch setup
 | `nexarch init-agent --bind-to-external-key <key> [--bind-relationship-type <code>]` | Optionally bind the agent node to an existing graph external key |
 | `nexarch init-agent` (default behavior) | Also upserts technology component entities (host, OS, Node.js runtime) and links them to the agent |
 
+## Company context behavior
+
+- Company is selected during `nexarch login`.
+- If your user has one active company, login auto-selects it.
+- If your user has multiple active companies, login requires explicit selection.
+- To switch company later, run `nexarch login` again and pick another company.
+
 ## Requirements
 
 - Node.js 18 or later

package/dist/commands/agent-identify.js

@@ -0,0 +1,151 @@
+import process from "process";
+import { requireCredentials } from "../lib/credentials.js";
+import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
+function parseFlag(args, flag) {
+    return args.includes(flag);
+}
+function parseOptionValue(args, option) {
+    const idx = args.indexOf(option);
+    if (idx === -1)
+        return null;
+    const value = args[idx + 1];
+    if (!value || value.startsWith("--"))
+        return null;
+    return value;
+}
+function parseToolText(result) {
+    const text = result.content?.[0]?.text ?? "{}";
+    return JSON.parse(text);
+}
+function getDefaultAgentId() {
+    const osUser = process.env.USERNAME || process.env.USER || "unknown";
+    const host = process.env.HOSTNAME || "unknown-host";
+    return `nexarch-cli:${osUser}@${host}`;
+}
+function parseCsv(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+export async function agentIdentify(args) {
+    const asJson = parseFlag(args, "--json");
+    const agentId = parseOptionValue(args, "--agent-id") ?? getDefaultAgentId();
+    const provider = parseOptionValue(args, "--provider");
+    const model = parseOptionValue(args, "--model");
+    const client = parseOptionValue(args, "--client");
+    const sessionId = parseOptionValue(args, "--session-id");
+    const framework = parseOptionValue(args, "--framework");
+    const toolVersion = parseOptionValue(args, "--tool-version");
+    const capabilities = parseCsv(parseOptionValue(args, "--capabilities"));
+    const notes = parseOptionValue(args, "--notes");
+    if (!provider || !model || !client) {
+        throw new Error("agent-identify requires --provider, --model, and --client");
+    }
+    const creds = requireCredentials();
+    await mcpInitialize({ companyId: creds.companyId });
+    const tools = await mcpListTools({ companyId: creds.companyId });
+    const toolNames = new Set(tools.map((t) => t.name));
+    const required = ["nexarch_upsert_entities"];
+    const missing = required.filter((name) => !toolNames.has(name));
+    if (missing.length) {
+        throw new Error(`missing required MCP tools: ${missing.join(", ")}`);
+    }
+    let policyBundleHash = null;
+    if (toolNames.has("nexarch_get_applied_policies")) {
+        try {
+            const policiesRaw = await callMcpTool("nexarch_get_applied_policies", {}, { companyId: creds.companyId });
+            const policies = parseToolText(policiesRaw);
+            policyBundleHash = policies.policyBundleHash ?? null;
+        }
+        catch {
+            policyBundleHash = null;
+        }
+    }
+    const nowIso = new Date().toISOString();
+    const upsertRaw = await callMcpTool("nexarch_upsert_entities", {
+        entities: [
+            {
+                externalKey: `agent:${agentId}`,
+                entityTypeCode: "agent",
+                name: `Agent ${agentId}`,
+                confidence: 1,
+                attributes: {
+                    identity: {
+                        source: "nexarch agent identify",
+                        capturedAt: nowIso,
+                        provider,
+                        model,
+                        client,
+                        sessionId,
+                        framework,
+                        toolVersion,
+                        capabilities,
+                        notes,
+                    },
+                },
+            },
+        ],
+        agentContext: {
+            agentId,
+            agentRunId: `agent-identify-${Date.now()}`,
+            repoRef: "nexarch-cli/agent-identify",
+            observedAt: nowIso,
+            source: "nexarch-cli",
+            model,
+            provider,
+        },
+        policyContext: policyBundleHash
+            ? {
+                policyBundleHash,
+                alignmentSummary: {
+                    score: 1,
+                    violations: [],
+                    waivers: [],
+                },
+            }
+            : undefined,
+        dryRun: false,
+    }, { companyId: creds.companyId });
+    const upsert = parseToolText(upsertRaw);
+    const failed = Number(upsert.summary?.failed ?? 0) > 0;
+    const firstResult = upsert.results?.[0];
+    const output = {
+        ok: !failed,
+        detail: failed ? `failed (${upsert.errors?.[0]?.error ?? "unknown"})` : `agent ${firstResult?.action ?? "updated"}`,
+        agentId,
+        graphEntityId: firstResult?.graphEntityId ?? null,
+        identity: {
+            provider,
+            model,
+            client,
+            sessionId,
+            framework,
+            toolVersion,
+            capabilities,
+            notes,
+            capturedAt: nowIso,
+        },
+    };
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        if (!output.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (output.ok) {
+        console.log("✅ Agent identity captured.");
+        console.log(`Agent: ${agentId}`);
+        console.log(`Provider/Model: ${provider} / ${model}`);
+        console.log(`Client: ${client}`);
+        if (framework)
+            console.log(`Framework: ${framework}`);
+    }
+    else {
+        console.log("⚠ Agent identity capture failed.");
+        console.log(output.detail);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/init-agent.js

@@ -1,8 +1,10 @@
-import { arch, hostname, platform, release, type as osType, userInfo } from "os";
+import { arch, homedir, hostname, platform, release, type as osType, userInfo } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
 import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
-const CLI_VERSION = "0.1.8";
+const CLI_VERSION = "0.1.12";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {
@@ -80,12 +82,89 @@ async function emitInitObservation(params) {
                     waivers: [],
                 },
             },
-        });
+        }, { companyId: params.companyId });
     }
     catch {
         // non-fatal telemetry path
     }
 }
+function writeAgentBootstrap(params) {
+    const dir = join(homedir(), ".nexarch");
+    mkdirSync(dir, { recursive: true });
+    const filePath = join(dir, "agent-bootstrap.md");
+    const identifyCmd = [
+        `nexarch agent identify`,
+        `--agent-id "${params.agentId}"`,
+        `--provider "<anthropic|openai|google|other>"`,
+        `--model "<model-id e.g. claude-sonnet-4-6>"`,
+        `--client "<claude-code|cursor|copilot|other>"`,
+        `--framework "<openclaw|n8n|m365-agent-framework|other>"`,
+        `--session-id "<your current session id if known, otherwise omit>"`,
+        `--tool-version "<your tool version if known, otherwise omit>"`,
+        `--capabilities "<comma,separated,capabilities>"`,
+        `--json`,
+    ].join(" \\\n  ");
+    const content = `# Nexarch Agent Bootstrap
+
+This file was written by \`nexarch init-agent\` on ${new Date().toISOString()}.
+It contains instructions for a Claude Code agent to complete its Nexarch registration.
+
+## What has already been registered
+
+The following entities are now in the architecture graph:
+
+| Entity | Name | Type |
+|--------|------|------|
+| Agent | \`${params.agentId}\` | agent |
+| Host | \`Host ${params.hostname}\` | tech_compute |
+| OS | \`${params.osPlatform} ${params.osRelease}\` | tech_operating_system |
+| Runtime | \`Node.js ${params.nodeVersion}\` | tech_runtime |
+
+## Your task
+
+Run the command below, substituting your own values for the placeholders.
+Return ONLY the completed command (no markdown, no explanation) — it will be executed directly.
+
+\`\`\`
+${identifyCmd}
+\`\`\`
+
+Fill in:
+- **provider** — your AI provider (e.g. \`anthropic\`)
+- **model** — the exact model ID you are running as (e.g. \`claude-sonnet-4-6\`)
+- **client** — the tool you are running inside (e.g. \`claude-code\`)
+- **framework** — the agent framework in use (e.g. \`openclaw\`)
+- **session-id** — your current session ID if available
+- **tool-version** — your tool version if available
+- **capabilities** — comma-separated list of your capabilities (e.g. \`code,files,bash,web\`)
+
+Omit any flag whose value you genuinely do not know rather than guessing.
+
+After running, confirm \`"ok": true\` in the JSON output. No further action is needed.
+`;
+    writeFileSync(filePath, content, "utf8");
+    return filePath;
+}
+const CLAUDE_MD_SECTION_MARKER = "## Nexarch Agent Registration";
+const CLAUDE_MD_SECTION = `
+## Nexarch Agent Registration
+
+When a human has run \`nexarch login\` and \`nexarch init-agent\`, they will tell you to run \`nexarch agent prompt\`. Do so, read the output, and follow the instructions — it contains a pre-filled \`nexarch agent identify\` command for you to complete with your own provider, model, client, and capability values, then execute. Confirm \`"ok": true\` in the JSON output.
+`;
+function injectClaudeMd() {
+    const candidates = ["CLAUDE.md", "claude.md", "Claude.md"];
+    const found = candidates.find((name) => existsSync(join(process.cwd(), name)));
+    if (!found)
+        return null;
+    const filePath = join(process.cwd(), found);
+    const existing = readFileSync(filePath, "utf8");
+    if (existing.includes(CLAUDE_MD_SECTION_MARKER)) {
+        return { path: filePath, status: "already_present" };
+    }
+    const separator = existing.endsWith("\n") ? "" : "\n";
+    writeFileSync(filePath, existing + separator + CLAUDE_MD_SECTION, "utf8");
+    return { path: filePath, status: "injected" };
+}
 export async function initAgent(args) {
     const asJson = parseFlag(args, "--json");
     const strict = parseFlag(args, "--strict");
@@ -105,13 +184,14 @@ export async function initAgent(args) {
     };
     const checks = [];
     const creds = requireCredentials();
-    const init = await mcpInitialize();
+    const selectedCompanyId = creds.companyId;
+    const init = await mcpInitialize({ companyId: selectedCompanyId });
     checks.push({
         name: "mcp.initialize",
         ok: true,
         detail: `${init.serverInfo?.name ?? "unknown"}@${init.serverInfo?.version ?? "unknown"}`,
     });
-    const tools = await mcpListTools();
+    const tools = await mcpListTools({ companyId: selectedCompanyId });
     const toolNames = new Set(tools.map((t) => t.name));
     const required = [
         "nexarch_get_applied_policies",
@@ -126,7 +206,7 @@ export async function initAgent(args) {
         ok: missing.length === 0,
         detail: missing.length ? `missing: ${missing.join(", ")}` : `required tools present (${required.length})`,
     });
-    const policiesRaw = await callMcpTool("nexarch_get_applied_policies", {});
+    const policiesRaw = await callMcpTool("nexarch_get_applied_policies", {}, { companyId: selectedCompanyId });
     const policies = parseToolText(policiesRaw);
     checks.push({
         name: "governance.bootstrap",
@@ -135,7 +215,7 @@ export async function initAgent(args) {
             ? `policyBundleHash=${policies.policyBundleHash.slice(0, 12)}… policyCount=${policies.policyCount ?? 0}`
             : "missing policyBundleHash",
     });
-    const contractRaw = await callMcpTool("nexarch_get_ingest_contract", {});
+    const contractRaw = await callMcpTool("nexarch_get_ingest_contract", {}, { companyId: selectedCompanyId });
     const contract = parseToolText(contractRaw);
     checks.push({
         name: "ingest.contract",
@@ -243,7 +323,7 @@ export async function initAgent(args) {
                 },
             },
             dryRun: false,
-        });
+        }, { companyId: selectedCompanyId });
         const upsert = parseToolText(upsertRaw);
         const firstResult = upsert.results?.[0];
         const failed = Number(upsert.summary?.failed ?? 0) > 0;
@@ -259,6 +339,7 @@ export async function initAgent(args) {
         if (!registration.ok) {
             await emitInitObservation({
                 agentId,
+                companyId: selectedCompanyId,
                 policyBundleHash: policies.policyBundleHash,
                 message: `init-agent registration failed: ${registration.detail}`,
                 confidence: 1,
@@ -274,6 +355,7 @@ export async function initAgent(args) {
                     {
                         externalKey: hostExternalKey,
                         entityTypeCode: TECH_COMPONENT_ENTITY_TYPE,
+                        entitySubtypeCode: "tech_compute",
                         name: `Host ${runtime.hostname}`,
                         description: "Execution host for registered agent runtimes",
                         confidence: 0.95,
@@ -288,6 +370,7 @@ export async function initAgent(args) {
                     {
                         externalKey: osExternalKey,
                         entityTypeCode: TECH_COMPONENT_ENTITY_TYPE,
+                        entitySubtypeCode: "tech_operating_system",
                         name: `${runtime.osPlatform} ${runtime.osRelease}`,
                         description: "Operating system platform used by registered agents",
                         confidence: 0.95,
@@ -302,6 +385,7 @@ export async function initAgent(args) {
                     {
                         externalKey: nodeExternalKey,
                         entityTypeCode: TECH_COMPONENT_ENTITY_TYPE,
+                        entitySubtypeCode: "tech_runtime",
                         name: `Node.js ${runtime.nodeVersion}`,
                         description: "Node.js runtime used by nexarch-cli agent",
                         confidence: 0.95,
@@ -330,7 +414,7 @@ export async function initAgent(args) {
                     },
                 },
                 dryRun: false,
-            });
+            }, { companyId: selectedCompanyId });
             const techUpsert = parseToolText(techUpsertRaw);
             const techFailed = Number(techUpsert.summary?.failed ?? 0) > 0;
             techComponents = {
@@ -345,6 +429,7 @@ export async function initAgent(args) {
             if (!techComponents.ok) {
                 await emitInitObservation({
                     agentId,
+                    companyId: selectedCompanyId,
                     policyBundleHash: policies.policyBundleHash,
                     message: `init-agent technology component upsert failed: ${techComponents.detail}`,
                     confidence: 1,
@@ -394,7 +479,7 @@ export async function initAgent(args) {
                         },
                     },
                     dryRun: false,
-                });
+                }, { companyId: selectedCompanyId });
                 const relUpsert = parseToolText(techRelRaw);
                 const relFailed = Number(relUpsert.summary?.failed ?? 0) > 0;
                 techRelationships = {
@@ -409,6 +494,7 @@ export async function initAgent(args) {
                 if (!techRelationships.ok) {
                     await emitInitObservation({
                         agentId,
+                        companyId: selectedCompanyId,
                         policyBundleHash: policies.policyBundleHash,
                         message: `init-agent technology relationship upsert failed: ${techRelationships.detail}`,
                         confidence: 1,
@@ -449,7 +535,7 @@ export async function initAgent(args) {
                     },
                 },
                 dryRun: false,
-            });
+            }, { companyId: selectedCompanyId });
             const rel = parseToolText(relRaw);
             const relResult = rel.results?.[0];
             const relFailed = Number(rel.summary?.failed ?? 0) > 0;
@@ -466,6 +552,7 @@ export async function initAgent(args) {
             if (!binding.ok) {
                 await emitInitObservation({
                     agentId,
+                    companyId: selectedCompanyId,
                     policyBundleHash: policies.policyBundleHash,
                     message: `init-agent binding failed: ${binding.detail}`,
                     confidence: 1,
@@ -473,6 +560,29 @@ export async function initAgent(args) {
             }
         }
     }
+    let bootstrapFilePath = null;
+    let claudeMdResult = null;
+    if (registration.ok) {
+        try {
+            bootstrapFilePath = writeAgentBootstrap({
+                agentId,
+                hostname: runtime.hostname,
+                osPlatform: runtime.osPlatform,
+                osRelease: runtime.osRelease,
+                nodeVersion: runtime.nodeVersion,
+                arch: runtime.arch,
+            });
+        }
+        catch {
+            // non-fatal
+        }
+        try {
+            claudeMdResult = injectClaudeMd();
+        }
+        catch {
+            // non-fatal
+        }
+    }
     checks.push({
         name: "agent.registration",
         ok: registration.ok,
@@ -496,11 +606,17 @@ export async function initAgent(args) {
         });
     }
     const allPassed = checks.every((c) => c.ok);
+    const identifyPrompt = [
+        "Please identify your runtime so the workspace can register richer metadata.",
+        "Return ONLY the completed command below with real values (no markdown):",
+        `nexarch agent identify --agent-id \"${agentId}\" --provider \"<provider>\" --model \"<model>\" --client \"<client>\" --framework \"<openclaw|n8n|m365-agent-framework|other>\" --session-id \"<session-id>\" --tool-version \"<tool-version>\" --capabilities \"<capability1,capability2>\" --notes \"<optional notes>\" --json`,
+    ].join("\n");
     if (asJson) {
         const output = {
             ok: strict ? allPassed : true,
             passed: allPassed,
             strict,
+            status: allPassed ? "needs_agent_identity_followup" : "handshake_completed_with_issues",
             checks,
             summary: {
                 total: checks.length,
@@ -517,7 +633,16 @@ export async function initAgent(args) {
                 relationships: techRelationships,
             },
             binding,
+            followUp: {
+                required: allPassed,
+                type: "agent_identity",
+                detail: "Prompt the coding agent to self-identify and submit via nexarch agent identify",
+                prompt: identifyPrompt,
+                submitCommandTemplate: `nexarch agent identify --agent-id \"${agentId}\" --provider \"<provider>\" --model \"<model>\" --client \"<client>\" --framework \"<openclaw|n8n|m365-agent-framework|other>\" --session-id \"<session-id>\" --tool-version \"<tool-version>\" --capabilities \"<capability1,capability2>\" --notes \"<optional notes>\" --json`,
+            },
             companyId: creds.companyId,
+            bootstrapFile: bootstrapFilePath,
+            claudeMd: claudeMdResult ?? null,
         };
         process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
         if (strict && !allPassed)
@@ -539,6 +664,13 @@ export async function initAgent(args) {
     console.log("");
     if (allPassed) {
         console.log("✅ Agent handshake + registration completed.");
+        if (bootstrapFilePath) {
+            console.log(`\n📋 Bootstrap instructions written to: ${bootstrapFilePath}`);
+        }
+        if (claudeMdResult?.status === "injected") {
+            console.log(`📝 Nexarch registration instructions added to: ${claudeMdResult.path}`);
+        }
+        console.log("\n   Tell Claude: \"run nexarch agent prompt and follow the instructions\"");
     }
     else {
         console.log("⚠ Handshake/registration completed with issues.");

package/dist/commands/login.js

@@ -60,6 +60,8 @@ function waitForCallback(port, expectedState) {
             const state = url.searchParams.get("state");
             const token = url.searchParams.get("token");
             const companyId = url.searchParams.get("companyId");
+            const companyName = url.searchParams.get("companyName") ?? undefined;
+            const companyCode = url.searchParams.get("companyCode") ?? undefined;
             const error = url.searchParams.get("error");
             const html = (message) => `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Nexarch CLI</title>
         <style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0;background:#f8fafc}
@@ -90,7 +92,7 @@ function waitForCallback(port, expectedState) {
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(html("Authorization successful! You can close this tab and return to your terminal."));
             server.close();
-            settle(() => resolve({ token, companyId }));
+            settle(() => resolve({ token, companyId, companyName, companyCode }));
         });
         const timeout = setTimeout(() => {
             server.close();
@@ -103,18 +105,38 @@ function waitForCallback(port, expectedState) {
         });
     });
 }
-export async function login(_args) {
+function getArgValue(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1)
+        return null;
+    const v = args[idx + 1];
+    if (!v || v.startsWith("--"))
+        return null;
+    return v;
+}
+export async function login(args) {
     const state = generateState();
     const port = await findFreePort();
-    const authUrl = `${NEXARCH_URL}/auth/cli?port=${port}&state=${state}`;
+    const requestedCompany = getArgValue(args, "--company");
+    const qp = new URLSearchParams({ port: String(port), state });
+    if (requestedCompany)
+        qp.set("company", requestedCompany);
+    const authUrl = `${NEXARCH_URL}/auth/cli?${qp.toString()}`;
     console.log("Opening Nexarch in your browser…");
     console.log(`\n  ${authUrl}\n`);
     console.log("If the browser did not open, copy the URL above and paste it in manually.\n");
     openBrowser(authUrl);
-    const { token, companyId } = await waitForCallback(port, state);
+    const { token, companyId, companyName, companyCode } = await waitForCallback(port, state);
     const expiresAt = new Date();
     expiresAt.setDate(expiresAt.getDate() + 90);
-    saveCredentials({ token, email: "", company: "", companyId, expiresAt: expiresAt.toISOString() });
+    saveCredentials({
+        token,
+        email: "",
+        company: companyName ?? companyCode ?? "",
+        companyCode: companyCode ?? undefined,
+        companyId,
+        expiresAt: expiresAt.toISOString(),
+    });
     console.log("✓ Logged in successfully");
     console.log("\nRun `nexarch status` to verify your connection.");
 }

package/dist/commands/status.js

@@ -2,14 +2,13 @@ import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool } from "../lib/mcp.js";
 export async function status(_args) {
     const creds = requireCredentials();
+    const selectedCompanyId = creds.companyId;
     const expiresAt = new Date(creds.expiresAt);
     const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
     process.stdout.write("Connecting to mcp.nexarch.ai… ");
     let governance;
     try {
-        const result = await callMcpTool("nexarch_get_governance_summary", {
-            companyId: creds.companyId || undefined,
-        });
+        const result = await callMcpTool("nexarch_get_governance_summary", { companyId: selectedCompanyId || undefined }, { companyId: selectedCompanyId || undefined });
         governance = JSON.parse(result.content[0]?.text ?? "{}");
     }
     catch (err) {

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import { homedir } from "os";
+import { readFileSync } from "fs";
+import { join } from "path";
 import { login } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
 import { status } from "./commands/status.js";
@@ -6,6 +9,7 @@ import { setup } from "./commands/setup.js";
 import { mcpConfig } from "./commands/mcp-config.js";
 import { mcpProxy } from "./commands/mcp-proxy.js";
 import { initAgent } from "./commands/init-agent.js";
+import { agentIdentify } from "./commands/agent-identify.js";
 const [, , command, ...args] = process.argv;
 const commands = {
     login,
@@ -15,15 +19,35 @@ const commands = {
     "mcp-config": mcpConfig,
     "mcp-proxy": mcpProxy,
     "init-agent": initAgent,
+    "agent-identify": agentIdentify,
 };
 async function main() {
+    if (command === "agent") {
+        const [subcommand, ...subArgs] = args;
+        if (subcommand === "identify") {
+            await agentIdentify(subArgs);
+            return;
+        }
+        if (subcommand === "prompt") {
+            const filePath = join(homedir(), ".nexarch", "agent-bootstrap.md");
+            try {
+                process.stdout.write(readFileSync(filePath, "utf8") + "\n");
+            }
+            catch {
+                console.error("No bootstrap file found. Run 'nexarch init-agent' first.");
+                process.exit(1);
+            }
+            return;
+        }
+    }
     const handler = commands[command ?? ""];
     if (!handler) {
         console.log(`
 nexarch — Connect AI coding tools to your architecture workspace
 
 Usage:
-  nexarch login         Authenticate in the browser and store credentials
+  nexarch login         Authenticate in browser and store company-scoped credentials
+                        Option: --company <id>
   nexarch logout        Remove stored credentials
   nexarch status        Check connection and show architecture summary
   nexarch setup         Auto-configure your MCP client (Claude Desktop, Cursor, etc.)
@@ -33,6 +57,18 @@ Usage:
                         Options: --agent-id <id> --bind-to-external-key <key>
                                  --bind-relationship-type <code> --redact-hostname
                                  --json --strict
+  nexarch agent prompt
+                      Print bootstrap instructions for a Claude Code agent to complete
+                      its registration (written by init-agent). Tell Claude:
+                      "run nexarch agent prompt and follow the instructions"
+  nexarch agent identify
+                      Capture richer coding-agent identity metadata
+                      Options: --agent-id <id> --provider <provider> --model <model>
+                               --client <name> [--framework <name>] [--session-id <id>]
+                               [--tool-version <v>] [--capabilities <csv>]
+                               [--notes <text>] [--json]
+  nexarch agent-identify
+                      Alias of 'nexarch agent identify'
     `);
         process.exit(command ? 1 : 0);
     }

package/dist/lib/mcp.js

@@ -2,8 +2,9 @@ import https from "https";
 import { requireCredentials } from "./credentials.js";
 const MCP_GATEWAY_URL = "https://mcp.nexarch.ai";
 const REQUEST_TIMEOUT_MS = 30 * 1000;
-async function callMcpRpc(method, params = {}) {
+async function callMcpRpc(method, params = {}, options = {}) {
     const creds = requireCredentials();
+    const companyId = options.companyId ?? creds.companyId;
     const body = JSON.stringify({
         jsonrpc: "2.0",
         id: 1,
@@ -20,7 +21,7 @@ async function callMcpRpc(method, params = {}) {
             headers: {
                 "Content-Type": "application/json",
                 Authorization: `Bearer ${creds.token}`,
-                "x-company-id": creds.companyId,
+                "x-company-id": companyId,
                 "Content-Length": Buffer.byteLength(body),
             },
             timeout: REQUEST_TIMEOUT_MS,
@@ -54,18 +55,18 @@ async function callMcpRpc(method, params = {}) {
         req.end();
     });
 }
-export async function callMcpTool(toolName, toolArgs = {}) {
-    return callMcpRpc("tools/call", { name: toolName, arguments: toolArgs });
+export async function callMcpTool(toolName, toolArgs = {}, options = {}) {
+    return callMcpRpc("tools/call", { name: toolName, arguments: toolArgs }, options);
 }
-export async function mcpInitialize() {
+export async function mcpInitialize(options = {}) {
     return callMcpRpc("initialize", {
         protocolVersion: "2024-11-05",
         capabilities: {},
-        clientInfo: { name: "nexarch-cli", version: "0.1.8" },
-    });
+        clientInfo: { name: "nexarch-cli", version: "0.1.11" },
+    }, options);
 }
-export async function mcpListTools() {
-    const result = await callMcpRpc("tools/list", {});
+export async function mcpListTools(options = {}) {
+    const result = await callMcpRpc("tools/list", {}, options);
     return result.tools ?? [];
 }
 export async function forwardToGateway(token, companyId, body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexarch",
-  "version": "0.1.8",
+  "version": "0.1.12",
   "description": "Connect AI coding tools to your Nexarch architecture workspace",
   "keywords": [
     "nexarch",