nexarch 0.1.7 → 0.1.11

package/README.md

@@ -13,14 +13,22 @@ 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 |
-| `nexarch init-agent [--json] [--strict] [--agent-id <id>]` | Run onboarding handshake and mandatory `agent` entity registration in graph |
+| `nexarch init-agent [--json] [--strict] [--agent-id <id>] [--redact-hostname]` | Run onboarding handshake and mandatory `agent` entity registration in graph |
 | `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
 

package/dist/commands/init-agent.js

@@ -1,7 +1,10 @@
-import { hostname, userInfo } from "os";
+import { arch, hostname, platform, release, type as osType, userInfo } from "os";
+import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
-const CLI_VERSION = "0.1.7";
+const CLI_VERSION = "0.1.11";
+const AGENT_ENTITY_TYPE = "agent";
+const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {
     return args.includes(flag);
 }
@@ -23,6 +26,28 @@ function getDefaultAgentId() {
     const host = hostname() || "unknown-host";
     return `nexarch-cli:${osUser}@${host}`;
 }
+function getRuntimeMode() {
+    if (process.env.CI)
+        return "ci";
+    return "interactive";
+}
+function getSanitizedHostname(redactHostname) {
+    const raw = hostname() || "unknown-host";
+    return redactHostname ? "redacted" : raw;
+}
+function hasEntityType(contract, code) {
+    return (contract.ontology?.entityCodes ?? []).some((entityCode) => entityCode.toLowerCase() === code.toLowerCase());
+}
+function pickRelationshipType(contract) {
+    const available = new Set((contract.ontology?.relationshipCodes ?? []).map((c) => c.toLowerCase()));
+    if (available.has("depends_on"))
+        return "depends_on";
+    if (available.has("uses"))
+        return "uses";
+    if (available.has("runs_on"))
+        return "runs_on";
+    return null;
+}
 async function emitInitObservation(params) {
     if (!params.policyBundleHash)
         return;
@@ -55,7 +80,7 @@ async function emitInitObservation(params) {
                     waivers: [],
                 },
             },
-        });
+        }, { companyId: params.companyId });
     }
     catch {
         // non-fatal telemetry path
@@ -64,19 +89,30 @@ async function emitInitObservation(params) {
 export async function initAgent(args) {
     const asJson = parseFlag(args, "--json");
     const strict = parseFlag(args, "--strict");
+    const redactHostname = parseFlag(args, "--redact-hostname");
     const explicitAgentId = parseOptionValue(args, "--agent-id");
     const bindToExternalKey = parseOptionValue(args, "--bind-to-external-key");
     const bindRelationshipType = parseOptionValue(args, "--bind-relationship-type") ?? "depends_on";
     const agentId = explicitAgentId ?? getDefaultAgentId();
+    const runtime = {
+        osPlatform: platform(),
+        osType: osType(),
+        osRelease: release(),
+        arch: arch(),
+        hostname: getSanitizedHostname(redactHostname),
+        nodeVersion: process.version,
+        mode: getRuntimeMode(),
+    };
     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",
@@ -91,7 +127,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",
@@ -100,14 +136,14 @@ 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",
         ok: Boolean(contract.contractVersion),
         detail: `version=${contract.contractVersion ?? "unknown"}; entities=${contract.ontology?.entityCodes?.length ?? 0}; relationships=${contract.ontology?.relationshipCodes?.length ?? 0}`,
     });
-    const hasAgentType = (contract.ontology?.entityCodes ?? []).some((code) => code.toLowerCase() === "agent");
+    const hasAgentType = hasEntityType(contract, AGENT_ENTITY_TYPE);
     checks.push({
         name: "ontology.agent-type",
         ok: hasAgentType,
@@ -115,23 +151,51 @@ export async function initAgent(args) {
             ? "entity type 'agent' is enabled"
             : "entity type 'agent' is not enabled for this workspace ontology",
     });
+    const hasTechComponentType = hasEntityType(contract, TECH_COMPONENT_ENTITY_TYPE);
+    checks.push({
+        name: "ontology.technology-component-type",
+        ok: hasTechComponentType,
+        detail: hasTechComponentType
+            ? "entity type 'technology_component' is enabled"
+            : "entity type 'technology_component' is not enabled for this workspace ontology",
+    });
+    const relForTechBinding = pickRelationshipType(contract);
+    checks.push({
+        name: "ontology.agent-tech-relationship",
+        ok: Boolean(relForTechBinding),
+        detail: relForTechBinding
+            ? `using relationship '${relForTechBinding}' for agent->technology_component links`
+            : "no supported relationship code found (expected one of depends_on|uses|runs_on)",
+    });
     const preflightPassed = checks.every((c) => c.ok);
     let registration = {
         ok: false,
         detail: "registration not attempted",
     };
+    let techComponents = {
+        attempted: false,
+        ok: true,
+        detail: "not attempted",
+    };
+    let techRelationships = {
+        attempted: false,
+        ok: true,
+        detail: "not attempted",
+    };
     let binding = {
         attempted: false,
         ok: true,
         detail: "not requested",
     };
-    if (preflightPassed && policies.policyBundleHash) {
+    if (preflightPassed && policies.policyBundleHash && relForTechBinding) {
         const nowIso = new Date().toISOString();
+        const agentRunId = `init-agent-${Date.now()}`;
+        const agentExternalKey = `agent:${agentId}`;
         const upsertRaw = await callMcpTool("nexarch_upsert_entities", {
             entities: [
                 {
-                    externalKey: `agent:${agentId}`,
-                    entityTypeCode: "agent",
+                    externalKey: agentExternalKey,
+                    entityTypeCode: AGENT_ENTITY_TYPE,
                     name: `Agent ${agentId}`,
                     description: "Agent identity registered from nexarch init-agent handshake",
                     confidence: 1,
@@ -140,6 +204,21 @@ export async function initAgent(args) {
                         client: "nexarch-cli",
                         version: CLI_VERSION,
                         companyId: creds.companyId,
+                        governance: {
+                            policyBundleHash: policies.policyBundleHash,
+                            contractVersion: contract.contractVersion ?? null,
+                            policyCount: policies.policyCount ?? null,
+                            strict,
+                        },
+                        runtime: {
+                            os: runtime.osPlatform,
+                            osType: runtime.osType,
+                            osRelease: runtime.osRelease,
+                            arch: runtime.arch,
+                            hostname: runtime.hostname,
+                            nodeVersion: runtime.nodeVersion,
+                            mode: runtime.mode,
+                        },
                         handshake: {
                             completedAt: nowIso,
                             source: "init-agent",
@@ -149,7 +228,7 @@ export async function initAgent(args) {
             ],
             agentContext: {
                 agentId,
-                agentRunId: `init-agent-${Date.now()}`,
+                agentRunId,
                 repoRef: "nexarch-cli/init-agent",
                 observedAt: nowIso,
                 source: "nexarch-cli",
@@ -165,7 +244,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;
@@ -181,11 +260,169 @@ 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,
             });
         }
+        if (registration.ok) {
+            techComponents.attempted = true;
+            const hostExternalKey = `tech:host:${runtime.hostname}:${runtime.arch}`;
+            const osExternalKey = `tech:os:${runtime.osPlatform}:${runtime.osRelease}:${runtime.arch}`;
+            const nodeExternalKey = `tech:runtime:nodejs:${runtime.nodeVersion}`;
+            const techUpsertRaw = await callMcpTool("nexarch_upsert_entities", {
+                entities: [
+                    {
+                        externalKey: hostExternalKey,
+                        entityTypeCode: TECH_COMPONENT_ENTITY_TYPE,
+                        entitySubtypeCode: "tech_compute",
+                        name: `Host ${runtime.hostname}`,
+                        description: "Execution host for registered agent runtimes",
+                        confidence: 0.95,
+                        attributes: {
+                            kind: "host_machine",
+                            hostname: runtime.hostname,
+                            arch: runtime.arch,
+                            os: runtime.osPlatform,
+                            osRelease: runtime.osRelease,
+                        },
+                    },
+                    {
+                        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,
+                        attributes: {
+                            kind: "operating_system",
+                            os: runtime.osPlatform,
+                            osType: runtime.osType,
+                            osRelease: runtime.osRelease,
+                            arch: runtime.arch,
+                        },
+                    },
+                    {
+                        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,
+                        attributes: {
+                            kind: "runtime",
+                            runtime: "nodejs",
+                            version: runtime.nodeVersion,
+                        },
+                    },
+                ],
+                agentContext: {
+                    agentId,
+                    agentRunId: `${agentRunId}-tech`,
+                    repoRef: "nexarch-cli/init-agent",
+                    observedAt: nowIso,
+                    source: "nexarch-cli",
+                    model: "n/a",
+                    provider: "n/a",
+                },
+                policyContext: {
+                    policyBundleHash: policies.policyBundleHash,
+                    alignmentSummary: {
+                        score: 1,
+                        violations: [],
+                        waivers: [],
+                    },
+                },
+                dryRun: false,
+            }, { companyId: selectedCompanyId });
+            const techUpsert = parseToolText(techUpsertRaw);
+            const techFailed = Number(techUpsert.summary?.failed ?? 0) > 0;
+            techComponents = {
+                attempted: true,
+                ok: !techFailed,
+                detail: techFailed
+                    ? `technology component upsert failed (${techUpsert.errors?.[0]?.error ?? "unknown"})`
+                    : `upserted ${(techUpsert.summary?.succeeded ?? 0)} technology components`,
+                results: techUpsert.results,
+                errors: techUpsert.errors,
+            };
+            if (!techComponents.ok) {
+                await emitInitObservation({
+                    agentId,
+                    companyId: selectedCompanyId,
+                    policyBundleHash: policies.policyBundleHash,
+                    message: `init-agent technology component upsert failed: ${techComponents.detail}`,
+                    confidence: 1,
+                });
+            }
+            if (techComponents.ok) {
+                techRelationships.attempted = true;
+                const techRelRaw = await callMcpTool("nexarch_upsert_relationships", {
+                    relationships: [
+                        {
+                            relationshipTypeCode: relForTechBinding,
+                            fromEntityExternalKey: agentExternalKey,
+                            toEntityExternalKey: hostExternalKey,
+                            confidence: 0.95,
+                            attributes: { source: "nexarch-cli-init-agent", kind: "execution_host", createdAt: nowIso },
+                        },
+                        {
+                            relationshipTypeCode: relForTechBinding,
+                            fromEntityExternalKey: agentExternalKey,
+                            toEntityExternalKey: osExternalKey,
+                            confidence: 0.95,
+                            attributes: { source: "nexarch-cli-init-agent", kind: "operating_system", createdAt: nowIso },
+                        },
+                        {
+                            relationshipTypeCode: relForTechBinding,
+                            fromEntityExternalKey: agentExternalKey,
+                            toEntityExternalKey: nodeExternalKey,
+                            confidence: 0.95,
+                            attributes: { source: "nexarch-cli-init-agent", kind: "runtime", createdAt: nowIso },
+                        },
+                    ],
+                    agentContext: {
+                        agentId,
+                        agentRunId: `${agentRunId}-tech-rel`,
+                        repoRef: "nexarch-cli/init-agent",
+                        observedAt: nowIso,
+                        source: "nexarch-cli",
+                        model: "n/a",
+                        provider: "n/a",
+                    },
+                    policyContext: {
+                        policyBundleHash: policies.policyBundleHash,
+                        alignmentSummary: {
+                            score: 1,
+                            violations: [],
+                            waivers: [],
+                        },
+                    },
+                    dryRun: false,
+                }, { companyId: selectedCompanyId });
+                const relUpsert = parseToolText(techRelRaw);
+                const relFailed = Number(relUpsert.summary?.failed ?? 0) > 0;
+                techRelationships = {
+                    attempted: true,
+                    ok: !relFailed,
+                    detail: relFailed
+                        ? `technology relationship upsert failed (${relUpsert.errors?.[0]?.error ?? "unknown"})`
+                        : `upserted ${(relUpsert.summary?.succeeded ?? 0)} technology relationships`,
+                    results: relUpsert.results,
+                    errors: relUpsert.errors,
+                };
+                if (!techRelationships.ok) {
+                    await emitInitObservation({
+                        agentId,
+                        companyId: selectedCompanyId,
+                        policyBundleHash: policies.policyBundleHash,
+                        message: `init-agent technology relationship upsert failed: ${techRelationships.detail}`,
+                        confidence: 1,
+                    });
+                }
+            }
+        }
         if (registration.ok && bindToExternalKey) {
             binding.attempted = true;
             const relRaw = await callMcpTool("nexarch_upsert_relationships", {
@@ -219,7 +456,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;
@@ -236,6 +473,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,
@@ -248,6 +486,16 @@ export async function initAgent(args) {
         ok: registration.ok,
         detail: registration.detail,
     });
+    checks.push({
+        name: "technology.components",
+        ok: techComponents.ok,
+        detail: techComponents.detail,
+    });
+    checks.push({
+        name: "technology.relationships",
+        ok: techRelationships.ok,
+        detail: techRelationships.detail,
+    });
     if (binding.attempted) {
         checks.push({
             name: "agent.binding",
@@ -270,7 +518,12 @@ export async function initAgent(args) {
             policyBundleHash: policies.policyBundleHash ?? null,
             contractVersion: contract.contractVersion ?? null,
             agentId,
+            runtime,
             registration,
+            technology: {
+                components: techComponents,
+                relationships: techRelationships,
+            },
             binding,
             companyId: creds.companyId,
         };

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

@@ -23,7 +23,8 @@ async function main() {
 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.)
@@ -31,7 +32,8 @@ Usage:
   nexarch mcp-proxy     Run as stdio MCP proxy (used by MCP clients)
   nexarch init-agent    Run handshake + mandatory agent registration in graph
                         Options: --agent-id <id> --bind-to-external-key <key>
-                                 --bind-relationship-type <code> --json --strict
+                                 --bind-relationship-type <code> --redact-hostname
+                                 --json --strict
     `);
         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.7" },
-    });
+        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.7",
+  "version": "0.1.11",
   "description": "Connect AI coding tools to your Nexarch architecture workspace",
   "keywords": [
     "nexarch",